From 89ba9269cfeb1df6b8d77b3c99fb4a86a154a73c Mon Sep 17 00:00:00 2001
From: Dhruv Bhanushali <dhruv_b@live.com>
Date: Sat, 12 Nov 2022 21:33:02 +0400
Subject: [PATCH 1/6] Add `nunjucks` and update `@actions/core`

---
 package-lock.json | 101 +++++++++++++++++++++++++++++++++++++++++-----
 package.json      |   3 +-
 2 files changed, 94 insertions(+), 10 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 8e2492cf..583524a7 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -16,7 +16,8 @@
         "action-input-parser": "^1.2.33",
         "fs-extra": "^10.1.0",
         "js-yaml": "^4.1.0",
-        "node-readfiles": "0.2.0"
+        "node-readfiles": "0.2.0",
+        "nunjucks": "^3.2.3"
       },
       "devDependencies": {
         "@betahuhn/config": "^1.2.0",
@@ -26,11 +27,12 @@
       }
     },
     "node_modules/@actions/core": {
-      "version": "1.8.2",
-      "resolved": "https://registry.npmjs.org/@actions/core/-/core-1.8.2.tgz",
-      "integrity": "sha512-FXcBL7nyik8K5ODeCKlxi+vts7torOkoDAKfeh61EAkAy1HAvwn9uVzZBY0f15YcQTcZZ2/iSGBFHEuioZWfDA==",
+      "version": "1.10.0",
+      "resolved": "https://registry.npmjs.org/@actions/core/-/core-1.10.0.tgz",
+      "integrity": "sha512-2aZDDa3zrrZbP5ZYg159sNoLRb61nQ7awl5pSvIq5Qpj81vwDzdMRKzkWJGJuwVvWpvZKx7vspJALyvaaIQyug==",
       "dependencies": {
-        "@actions/http-client": "^2.0.1"
+        "@actions/http-client": "^2.0.1",
+        "uuid": "^8.3.2"
       }
     },
     "node_modules/@actions/github": {
@@ -745,6 +747,11 @@
         "ncc": "dist/ncc/cli.js"
       }
     },
+    "node_modules/a-sync-waterfall": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/a-sync-waterfall/-/a-sync-waterfall-1.0.1.tgz",
+      "integrity": "sha512-RYTOHHdWipFUliRFMCS4X2Yn2X8M87V/OpSqWzKKOGhzqyUxzyVmhHDH9sAvG+ZuQf/TAOFsLCpMw09I1ufUnA=="
+    },
     "node_modules/acorn": {
       "version": "7.4.1",
       "resolved": "https://registry.npmjs.org/acorn/-/acorn-7.4.1.tgz",
@@ -913,6 +920,11 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/asap": {
+      "version": "2.0.6",
+      "resolved": "https://registry.npmjs.org/asap/-/asap-2.0.6.tgz",
+      "integrity": "sha512-BSHWgDSAiKs50o2Re8ppvp3seVHXSRM44cdSsT9FfNEUUZLOGWVCsiWaRPWM1Znn+mqZ1OfVZ3z3DWEzSp7hRA=="
+    },
     "node_modules/astral-regex": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/astral-regex/-/astral-regex-2.0.0.tgz",
@@ -1100,6 +1112,14 @@
         "node": ">=0.1.90"
       }
     },
+    "node_modules/commander": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-5.1.0.tgz",
+      "integrity": "sha512-P0CysNDQ7rtVw4QIQtm+MRxV66vKFSvlsQvGYXZWR3qFU0jlMKHZZZgw8e+8DSah4UDKMqnknRDQz+xuQXQ/Zg==",
+      "engines": {
+        "node": ">= 6"
+      }
+    },
     "node_modules/compare-func": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/compare-func/-/compare-func-2.0.0.tgz",
@@ -6220,6 +6240,30 @@
       "inBundle": true,
       "license": "ISC"
     },
+    "node_modules/nunjucks": {
+      "version": "3.2.3",
+      "resolved": "https://registry.npmjs.org/nunjucks/-/nunjucks-3.2.3.tgz",
+      "integrity": "sha512-psb6xjLj47+fE76JdZwskvwG4MYsQKXUtMsPh6U0YMvmyjRtKRFcxnlXGWglNybtNTNVmGdp94K62/+NjF5FDQ==",
+      "dependencies": {
+        "a-sync-waterfall": "^1.0.0",
+        "asap": "^2.0.3",
+        "commander": "^5.1.0"
+      },
+      "bin": {
+        "nunjucks-precompile": "bin/precompile"
+      },
+      "engines": {
+        "node": ">= 6.9.0"
+      },
+      "peerDependencies": {
+        "chokidar": "^3.3.0"
+      },
+      "peerDependenciesMeta": {
+        "chokidar": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/object-inspect": {
       "version": "1.11.0",
       "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.11.0.tgz",
@@ -7665,6 +7709,14 @@
       "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=",
       "dev": true
     },
+    "node_modules/uuid": {
+      "version": "8.3.2",
+      "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz",
+      "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==",
+      "bin": {
+        "uuid": "dist/bin/uuid"
+      }
+    },
     "node_modules/v8-compile-cache": {
       "version": "2.3.0",
       "resolved": "https://registry.npmjs.org/v8-compile-cache/-/v8-compile-cache-2.3.0.tgz",
@@ -7843,11 +7895,12 @@
   },
   "dependencies": {
     "@actions/core": {
-      "version": "1.8.2",
-      "resolved": "https://registry.npmjs.org/@actions/core/-/core-1.8.2.tgz",
-      "integrity": "sha512-FXcBL7nyik8K5ODeCKlxi+vts7torOkoDAKfeh61EAkAy1HAvwn9uVzZBY0f15YcQTcZZ2/iSGBFHEuioZWfDA==",
+      "version": "1.10.0",
+      "resolved": "https://registry.npmjs.org/@actions/core/-/core-1.10.0.tgz",
+      "integrity": "sha512-2aZDDa3zrrZbP5ZYg159sNoLRb61nQ7awl5pSvIq5Qpj81vwDzdMRKzkWJGJuwVvWpvZKx7vspJALyvaaIQyug==",
       "requires": {
-        "@actions/http-client": "^2.0.1"
+        "@actions/http-client": "^2.0.1",
+        "uuid": "^8.3.2"
       }
     },
     "@actions/github": {
@@ -8479,6 +8532,11 @@
       "integrity": "sha512-G9h5ZLBJ/V57Ou9vz5hI8pda/YQX5HQszCs3AmIus3XzsmRn/0Ptic5otD3xVST8QLKk7AMk7AqpsyQGN7MZ9A==",
       "dev": true
     },
+    "a-sync-waterfall": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/a-sync-waterfall/-/a-sync-waterfall-1.0.1.tgz",
+      "integrity": "sha512-RYTOHHdWipFUliRFMCS4X2Yn2X8M87V/OpSqWzKKOGhzqyUxzyVmhHDH9sAvG+ZuQf/TAOFsLCpMw09I1ufUnA=="
+    },
     "acorn": {
       "version": "7.4.1",
       "resolved": "https://registry.npmjs.org/acorn/-/acorn-7.4.1.tgz",
@@ -8604,6 +8662,11 @@
       "integrity": "sha1-iYUI2iIm84DfkEcoRWhJwVAaSw0=",
       "dev": true
     },
+    "asap": {
+      "version": "2.0.6",
+      "resolved": "https://registry.npmjs.org/asap/-/asap-2.0.6.tgz",
+      "integrity": "sha512-BSHWgDSAiKs50o2Re8ppvp3seVHXSRM44cdSsT9FfNEUUZLOGWVCsiWaRPWM1Znn+mqZ1OfVZ3z3DWEzSp7hRA=="
+    },
     "astral-regex": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/astral-regex/-/astral-regex-2.0.0.tgz",
@@ -8752,6 +8815,11 @@
       "integrity": "sha1-BDP0TYCWgP3rYO0mDxsMJi6CpAs=",
       "dev": true
     },
+    "commander": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-5.1.0.tgz",
+      "integrity": "sha512-P0CysNDQ7rtVw4QIQtm+MRxV66vKFSvlsQvGYXZWR3qFU0jlMKHZZZgw8e+8DSah4UDKMqnknRDQz+xuQXQ/Zg=="
+    },
     "compare-func": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/compare-func/-/compare-func-2.0.0.tgz",
@@ -12574,6 +12642,16 @@
         "path-key": "^3.0.0"
       }
     },
+    "nunjucks": {
+      "version": "3.2.3",
+      "resolved": "https://registry.npmjs.org/nunjucks/-/nunjucks-3.2.3.tgz",
+      "integrity": "sha512-psb6xjLj47+fE76JdZwskvwG4MYsQKXUtMsPh6U0YMvmyjRtKRFcxnlXGWglNybtNTNVmGdp94K62/+NjF5FDQ==",
+      "requires": {
+        "a-sync-waterfall": "^1.0.0",
+        "asap": "^2.0.3",
+        "commander": "^5.1.0"
+      }
+    },
     "object-inspect": {
       "version": "1.11.0",
       "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.11.0.tgz",
@@ -13660,6 +13738,11 @@
       "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=",
       "dev": true
     },
+    "uuid": {
+      "version": "8.3.2",
+      "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz",
+      "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg=="
+    },
     "v8-compile-cache": {
       "version": "2.3.0",
       "resolved": "https://registry.npmjs.org/v8-compile-cache/-/v8-compile-cache-2.3.0.tgz",
diff --git a/package.json b/package.json
index c03b431e..cf31fc64 100644
--- a/package.json
+++ b/package.json
@@ -34,7 +34,8 @@
     "action-input-parser": "^1.2.33",
     "fs-extra": "^10.1.0",
     "js-yaml": "^4.1.0",
-    "node-readfiles": "0.2.0"
+    "node-readfiles": "0.2.0",
+    "nunjucks": "^3.2.3"
   },
   "devDependencies": {
     "@betahuhn/config": "^1.2.0",

From 01ece5263a6b06392baf213210f5415b87bebdd0 Mon Sep 17 00:00:00 2001
From: Dhruv Bhanushali <dhruv_b@live.com>
Date: Sat, 12 Nov 2022 23:18:16 +0400
Subject: [PATCH 2/6] Read template info from YAML config file

---
 src/config.js | 13 ++++---------
 1 file changed, 4 insertions(+), 9 deletions(-)

diff --git a/src/config.js b/src/config.js
index 56c17fff..e9067083 100644
--- a/src/config.js
+++ b/src/config.js
@@ -5,6 +5,7 @@ const path = require('path')
 const { getInput } = require('action-input-parser')
 
 const REPLACE_DEFAULT = true
+const TEMPLATE_DEFAULT = false
 const DELETE_ORPHANED_DEFAULT = false
 
 let context
@@ -174,20 +175,14 @@ const parseExclude = (text, src) => {
 
 const parseFiles = (files) => {
 	return files.map((item) => {
-
-		if (typeof item === 'string') {
-			return {
-				source: item,
-				dest: item,
-				replace: REPLACE_DEFAULT,
-				deleteOrphaned: DELETE_ORPHANED_DEFAULT
-			}
-		}
+		if (typeof item === 'string')
+			item = { source: item }
 
 		if (item.source !== undefined) {
 			return {
 				source: item.source,
 				dest: item.dest || item.source,
+				template: item.template === undefined ? TEMPLATE_DEFAULT : item.template,
 				replace: item.replace === undefined ? REPLACE_DEFAULT : item.replace,
 				deleteOrphaned: item.deleteOrphaned === undefined ? DELETE_ORPHANED_DEFAULT : item.deleteOrphaned,
 				exclude: parseExclude(item.exclude, item.source)

From 6438249b3e5b7cc952abc1c0ac0b17769ec33e02 Mon Sep 17 00:00:00 2001
From: Dhruv Bhanushali <dhruv_b@live.com>
Date: Sat, 12 Nov 2022 23:19:09 +0400
Subject: [PATCH 3/6] Render templates when copying files

---
 src/helpers.js | 40 +++++++++++++++++++++++++++++++++++-----
 src/index.js   |  4 +---
 2 files changed, 36 insertions(+), 8 deletions(-)

diff --git a/src/helpers.js b/src/helpers.js
index 5c3aa40c..d45341bd 100644
--- a/src/helpers.js
+++ b/src/helpers.js
@@ -3,6 +3,9 @@ const readfiles = require('node-readfiles')
 const { exec } = require('child_process')
 const core = require('@actions/core')
 const path = require('path')
+const nunjucks = require('nunjucks')
+
+nunjucks.configure({ autoescape: true, trimBlocks: true, lstripBlocks: true })
 
 // From https://github.com/toniov/p-iteration/blob/master/lib/static-methods.js - MIT © Antonio V
 const forEach = async (array, callback) => {
@@ -63,13 +66,19 @@ const pathIsDirectory = async (path) => {
 	return stat.isDirectory()
 }
 
-const copy = async (src, dest, deleteOrphaned, exclude) => {
+const write = async (src, dest, context) => {
+	if (typeof context !== 'object') {
+		context = {}
+	}
+	const content = nunjucks.render(src, context)
+	await fs.outputFile(dest, content)
+}
 
-	core.debug(`CP: ${ src } TO ${ dest }`)
+const copy = async (src, dest, isDirectory, file) => {
+	const deleteOrphaned = isDirectory && file.deleteOrphaned
 
 	const filterFunc = (file) => {
-
-		if (exclude !== undefined && exclude.includes(file)) {
+		if (file.exclude !== undefined && file.exclude.includes(file)) {
 			core.debug(`Excluding file ${ file }`)
 			return false
 		}
@@ -77,7 +86,28 @@ const copy = async (src, dest, deleteOrphaned, exclude) => {
 		return true
 	}
 
-	await fs.copy(src, dest, exclude !== undefined && { filter: filterFunc })
+	if (file.template) {
+		if (isDirectory) {
+			core.debug(`Render all files in directory ${ src } to ${ dest }`)
+
+			const srcFileList = await readfiles(src, { readContents: false, hidden: true })
+			for (const file of srcFileList) {
+				if (!filterFunc(file)) { continue }
+
+				const srcPath = path.join(src, file)
+				const destPath = path.join(dest, file)
+				await write(srcPath, destPath, file.template)
+			}
+		} else {
+			core.debug(`Render file ${ src } to ${ dest }`)
+
+			await write(src, dest, file.template)
+		}
+	} else {
+		core.debug(`Copy ${ src } to ${ dest }`)
+		await fs.copy(src, dest, file.exclude !== undefined && { filter: filterFunc })
+	}
+
 
 	// If it is a directory and deleteOrphaned is enabled - check if there are any files that were removed from source dir and remove them in destination dir
 	if (deleteOrphaned) {
diff --git a/src/index.js b/src/index.js
index 53c62907..18be6315 100644
--- a/src/index.js
+++ b/src/index.js
@@ -73,9 +73,7 @@ const run = async () => {
 
 				if (isDirectory) core.info(`Source is directory`)
 
-				const deleteOrphaned = isDirectory && file.deleteOrphaned
-
-				await copy(source, dest, deleteOrphaned, file.exclude)
+				await copy(source, dest, isDirectory, file)
 
 				await git.add(file.dest)
 

From c338094c4942aa9790ea284d7c3bb8084f6ef392 Mon Sep 17 00:00:00 2001
From: Dhruv Bhanushali <dhruv_b@live.com>
Date: Sat, 12 Nov 2022 23:20:04 +0400
Subject: [PATCH 4/6] Compile JS files into action

---
 dist/index.js | 9559 ++++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 9079 insertions(+), 480 deletions(-)

diff --git a/dist/index.js b/dist/index.js
index f0bdc734..7199f03c 100644
--- a/dist/index.js
+++ b/dist/index.js
@@ -169,13 +169,9 @@ function exportVariable(name, val) {
     process.env[name] = convertedVal;
     const filePath = process.env['GITHUB_ENV'] || '';
     if (filePath) {
-        const delimiter = '_GitHubActionsFileCommandDelimeter_';
-        const commandValue = `${name}<<${delimiter}${os.EOL}${convertedVal}${os.EOL}${delimiter}`;
-        file_command_1.issueCommand('ENV', commandValue);
-    }
-    else {
-        command_1.issueCommand('set-env', { name }, convertedVal);
+        return file_command_1.issueFileCommand('ENV', file_command_1.prepareKeyValueMessage(name, val));
     }
+    command_1.issueCommand('set-env', { name }, convertedVal);
 }
 exports.exportVariable = exportVariable;
 /**
@@ -193,7 +189,7 @@ exports.setSecret = setSecret;
 function addPath(inputPath) {
     const filePath = process.env['GITHUB_PATH'] || '';
     if (filePath) {
-        file_command_1.issueCommand('PATH', inputPath);
+        file_command_1.issueFileCommand('PATH', inputPath);
     }
     else {
         command_1.issueCommand('add-path', {}, inputPath);
@@ -233,7 +229,10 @@ function getMultilineInput(name, options) {
     const inputs = getInput(name, options)
         .split('\n')
         .filter(x => x !== '');
-    return inputs;
+    if (options && options.trimWhitespace === false) {
+        return inputs;
+    }
+    return inputs.map(input => input.trim());
 }
 exports.getMultilineInput = getMultilineInput;
 /**
@@ -266,8 +265,12 @@ exports.getBooleanInput = getBooleanInput;
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function setOutput(name, value) {
+    const filePath = process.env['GITHUB_OUTPUT'] || '';
+    if (filePath) {
+        return file_command_1.issueFileCommand('OUTPUT', file_command_1.prepareKeyValueMessage(name, value));
+    }
     process.stdout.write(os.EOL);
-    command_1.issueCommand('set-output', { name }, value);
+    command_1.issueCommand('set-output', { name }, utils_1.toCommandValue(value));
 }
 exports.setOutput = setOutput;
 /**
@@ -396,7 +399,11 @@ exports.group = group;
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function saveState(name, value) {
-    command_1.issueCommand('save-state', { name }, value);
+    const filePath = process.env['GITHUB_STATE'] || '';
+    if (filePath) {
+        return file_command_1.issueFileCommand('STATE', file_command_1.prepareKeyValueMessage(name, value));
+    }
+    command_1.issueCommand('save-state', { name }, utils_1.toCommandValue(value));
 }
 exports.saveState = saveState;
 /**
@@ -425,6 +432,13 @@ Object.defineProperty(exports, "summary", ({ enumerable: true, get: function ()
  */
 var summary_2 = __nccwpck_require__(1327);
 Object.defineProperty(exports, "markdownSummary", ({ enumerable: true, get: function () { return summary_2.markdownSummary; } }));
+/**
+ * Path exports
+ */
+var path_utils_1 = __nccwpck_require__(2981);
+Object.defineProperty(exports, "toPosixPath", ({ enumerable: true, get: function () { return path_utils_1.toPosixPath; } }));
+Object.defineProperty(exports, "toWin32Path", ({ enumerable: true, get: function () { return path_utils_1.toWin32Path; } }));
+Object.defineProperty(exports, "toPlatformPath", ({ enumerable: true, get: function () { return path_utils_1.toPlatformPath; } }));
 //# sourceMappingURL=core.js.map
 
 /***/ }),
@@ -455,13 +469,14 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.issueCommand = void 0;
+exports.prepareKeyValueMessage = exports.issueFileCommand = void 0;
 // We use any as a valid input type
 /* eslint-disable @typescript-eslint/no-explicit-any */
 const fs = __importStar(__nccwpck_require__(7147));
 const os = __importStar(__nccwpck_require__(2037));
+const uuid_1 = __nccwpck_require__(5840);
 const utils_1 = __nccwpck_require__(5278);
-function issueCommand(command, message) {
+function issueFileCommand(command, message) {
     const filePath = process.env[`GITHUB_${command}`];
     if (!filePath) {
         throw new Error(`Unable to find environment variable for file command ${command}`);
@@ -473,7 +488,22 @@ function issueCommand(command, message) {
         encoding: 'utf8'
     });
 }
-exports.issueCommand = issueCommand;
+exports.issueFileCommand = issueFileCommand;
+function prepareKeyValueMessage(key, value) {
+    const delimiter = `ghadelimiter_${uuid_1.v4()}`;
+    const convertedValue = utils_1.toCommandValue(value);
+    // These should realistically never happen, but just in case someone finds a
+    // way to exploit uuid generation let's not allow keys or values that contain
+    // the delimiter.
+    if (key.includes(delimiter)) {
+        throw new Error(`Unexpected input: name should not contain the delimiter "${delimiter}"`);
+    }
+    if (convertedValue.includes(delimiter)) {
+        throw new Error(`Unexpected input: value should not contain the delimiter "${delimiter}"`);
+    }
+    return `${key}<<${delimiter}${os.EOL}${convertedValue}${os.EOL}${delimiter}`;
+}
+exports.prepareKeyValueMessage = prepareKeyValueMessage;
 //# sourceMappingURL=file-command.js.map
 
 /***/ }),
@@ -562,6 +592,71 @@ exports.OidcClient = OidcClient;
 
 /***/ }),
 
+/***/ 2981:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.toPlatformPath = exports.toWin32Path = exports.toPosixPath = void 0;
+const path = __importStar(__nccwpck_require__(1017));
+/**
+ * toPosixPath converts the given path to the posix form. On Windows, \\ will be
+ * replaced with /.
+ *
+ * @param pth. Path to transform.
+ * @return string Posix path.
+ */
+function toPosixPath(pth) {
+    return pth.replace(/[\\]/g, '/');
+}
+exports.toPosixPath = toPosixPath;
+/**
+ * toWin32Path converts the given path to the win32 form. On Linux, / will be
+ * replaced with \\.
+ *
+ * @param pth. Path to transform.
+ * @return string Win32 path.
+ */
+function toWin32Path(pth) {
+    return pth.replace(/[/]/g, '\\');
+}
+exports.toWin32Path = toWin32Path;
+/**
+ * toPlatformPath converts the given path to a platform-specific path. It does
+ * this by replacing instances of / and \ with the platform-specific path
+ * separator.
+ *
+ * @param pth The path to platformize.
+ * @return string The platform-specific path.
+ */
+function toPlatformPath(pth) {
+    return pth.replace(/[/\\]/g, path.sep);
+}
+exports.toPlatformPath = toPlatformPath;
+//# sourceMappingURL=path-utils.js.map
+
+/***/ }),
+
 /***/ 1327:
 /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
@@ -6535,6 +6630,96 @@ function pick(files, {added, modified, deleted, untracked, renamed}) {
 
 
 
+/***/ }),
+
+/***/ 3980:
+/***/ (function(module) {
+
+// MIT license (by Elan Shanker).
+(function(globals) {
+  'use strict';
+
+  var executeSync = function(){
+    var args = Array.prototype.slice.call(arguments);
+    if (typeof args[0] === 'function'){
+      args[0].apply(null, args.splice(1));
+    }
+  };
+
+  var executeAsync = function(fn){
+    if (typeof setImmediate === 'function') {
+      setImmediate(fn);
+    } else if (typeof process !== 'undefined' && process.nextTick) {
+      process.nextTick(fn);
+    } else {
+      setTimeout(fn, 0);
+    }
+  };
+
+  var makeIterator = function (tasks) {
+    var makeCallback = function (index) {
+      var fn = function () {
+        if (tasks.length) {
+          tasks[index].apply(null, arguments);
+        }
+        return fn.next();
+      };
+      fn.next = function () {
+        return (index < tasks.length - 1) ? makeCallback(index + 1): null;
+      };
+      return fn;
+    };
+    return makeCallback(0);
+  };
+  
+  var _isArray = Array.isArray || function(maybeArray){
+    return Object.prototype.toString.call(maybeArray) === '[object Array]';
+  };
+
+  var waterfall = function (tasks, callback, forceAsync) {
+    var nextTick = forceAsync ? executeAsync : executeSync;
+    callback = callback || function () {};
+    if (!_isArray(tasks)) {
+      var err = new Error('First argument to waterfall must be an array of functions');
+      return callback(err);
+    }
+    if (!tasks.length) {
+      return callback();
+    }
+    var wrapIterator = function (iterator) {
+      return function (err) {
+        if (err) {
+          callback.apply(null, arguments);
+          callback = function () {};
+        } else {
+          var args = Array.prototype.slice.call(arguments, 1);
+          var next = iterator.next();
+          if (next) {
+            args.push(wrapIterator(next));
+          } else {
+            args.push(callback);
+          }
+          nextTick(function () {
+            iterator.apply(null, args);
+          });
+        }
+      };
+    };
+    wrapIterator(makeIterator(tasks))();
+  };
+
+  if (typeof define !== 'undefined' && define.amd) {
+    define([], function () {
+      return waterfall;
+    }); // RequireJS
+  } else if ( true && module.exports) {
+    module.exports = waterfall; // CommonJS
+  } else {
+    globals.waterfall = waterfall; // <script>
+  }
+})(this);
+
+
 /***/ }),
 
 /***/ 4623:
@@ -6638,6 +6823,188 @@ exports.getInput = getInput;
 module.exports.getInput = exports.getInput;
 
 
+/***/ }),
+
+/***/ 7943:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+var rawAsap = __nccwpck_require__(3691);
+var freeTasks = [];
+
+/**
+ * Calls a task as soon as possible after returning, in its own event, with
+ * priority over IO events. An exception thrown in a task can be handled by
+ * `process.on("uncaughtException") or `domain.on("error")`, but will otherwise
+ * crash the process. If the error is handled, all subsequent tasks will
+ * resume.
+ *
+ * @param {{call}} task A callable object, typically a function that takes no
+ * arguments.
+ */
+module.exports = asap;
+function asap(task) {
+    var rawTask;
+    if (freeTasks.length) {
+        rawTask = freeTasks.pop();
+    } else {
+        rawTask = new RawTask();
+    }
+    rawTask.task = task;
+    rawTask.domain = process.domain;
+    rawAsap(rawTask);
+}
+
+function RawTask() {
+    this.task = null;
+    this.domain = null;
+}
+
+RawTask.prototype.call = function () {
+    if (this.domain) {
+        this.domain.enter();
+    }
+    var threw = true;
+    try {
+        this.task.call();
+        threw = false;
+        // If the task throws an exception (presumably) Node.js restores the
+        // domain stack for the next event.
+        if (this.domain) {
+            this.domain.exit();
+        }
+    } finally {
+        // We use try/finally and a threw flag to avoid messing up stack traces
+        // when we catch and release errors.
+        if (threw) {
+            // In Node.js, uncaught exceptions are considered fatal errors.
+            // Re-throw them to interrupt flushing!
+            // Ensure that flushing continues if an uncaught exception is
+            // suppressed listening process.on("uncaughtException") or
+            // domain.on("error").
+            rawAsap.requestFlush();
+        }
+        // If the task threw an error, we do not want to exit the domain here.
+        // Exiting the domain would prevent the domain from catching the error.
+        this.task = null;
+        this.domain = null;
+        freeTasks.push(this);
+    }
+};
+
+
+
+/***/ }),
+
+/***/ 3691:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+var domain; // The domain module is executed on demand
+var hasSetImmediate = typeof setImmediate === "function";
+
+// Use the fastest means possible to execute a task in its own turn, with
+// priority over other events including network IO events in Node.js.
+//
+// An exception thrown by a task will permanently interrupt the processing of
+// subsequent tasks. The higher level `asap` function ensures that if an
+// exception is thrown by a task, that the task queue will continue flushing as
+// soon as possible, but if you use `rawAsap` directly, you are responsible to
+// either ensure that no exceptions are thrown from your task, or to manually
+// call `rawAsap.requestFlush` if an exception is thrown.
+module.exports = rawAsap;
+function rawAsap(task) {
+    if (!queue.length) {
+        requestFlush();
+        flushing = true;
+    }
+    // Avoids a function call
+    queue[queue.length] = task;
+}
+
+var queue = [];
+// Once a flush has been requested, no further calls to `requestFlush` are
+// necessary until the next `flush` completes.
+var flushing = false;
+// The position of the next task to execute in the task queue. This is
+// preserved between calls to `flush` so that it can be resumed if
+// a task throws an exception.
+var index = 0;
+// If a task schedules additional tasks recursively, the task queue can grow
+// unbounded. To prevent memory excaustion, the task queue will periodically
+// truncate already-completed tasks.
+var capacity = 1024;
+
+// The flush function processes all tasks that have been scheduled with
+// `rawAsap` unless and until one of those tasks throws an exception.
+// If a task throws an exception, `flush` ensures that its state will remain
+// consistent and will resume where it left off when called again.
+// However, `flush` does not make any arrangements to be called again if an
+// exception is thrown.
+function flush() {
+    while (index < queue.length) {
+        var currentIndex = index;
+        // Advance the index before calling the task. This ensures that we will
+        // begin flushing on the next task the task throws an error.
+        index = index + 1;
+        queue[currentIndex].call();
+        // Prevent leaking memory for long chains of recursive calls to `asap`.
+        // If we call `asap` within tasks scheduled by `asap`, the queue will
+        // grow, but to avoid an O(n) walk for every task we execute, we don't
+        // shift tasks off the queue after they have been executed.
+        // Instead, we periodically shift 1024 tasks off the queue.
+        if (index > capacity) {
+            // Manually shift all values starting at the index back to the
+            // beginning of the queue.
+            for (var scan = 0, newLength = queue.length - index; scan < newLength; scan++) {
+                queue[scan] = queue[scan + index];
+            }
+            queue.length -= index;
+            index = 0;
+        }
+    }
+    queue.length = 0;
+    index = 0;
+    flushing = false;
+}
+
+rawAsap.requestFlush = requestFlush;
+function requestFlush() {
+    // Ensure flushing is not bound to any domain.
+    // It is not sufficient to exit the domain, because domains exist on a stack.
+    // To execute code outside of any domain, the following dance is necessary.
+    var parentDomain = process.domain;
+    if (parentDomain) {
+        if (!domain) {
+            // Lazy execute the domain module.
+            // Only employed if the user elects to use domains.
+            domain = __nccwpck_require__(3639);
+        }
+        domain.active = process.domain = null;
+    }
+
+    // `setImmediate` is slower that `process.nextTick`, but `process.nextTick`
+    // cannot handle recursion.
+    // `requestFlush` will only be called recursively from `asap.js`, to resume
+    // flushing after an error is thrown into a domain.
+    // Conveniently, `setImmediate` was introduced in the same version
+    // `process.nextTick` started throwing recursion errors.
+    if (flushing && hasSetImmediate) {
+        setImmediate(flush);
+    } else {
+        process.nextTick(flush);
+    }
+
+    if (parentDomain) {
+        domain.active = process.domain = parentDomain;
+    }
+}
+
+
 /***/ }),
 
 /***/ 3682:
@@ -18643,591 +19010,8776 @@ module.exports = readfiles;
 
 /***/ }),
 
-/***/ 1223:
+/***/ 7006:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
-var wrappy = __nccwpck_require__(2940)
-module.exports = wrappy(once)
-module.exports.strict = wrappy(onceStrict)
+"use strict";
 
-once.proto = once(function () {
-  Object.defineProperty(Function.prototype, 'once', {
-    value: function () {
-      return once(this)
-    },
-    configurable: true
-  })
 
-  Object.defineProperty(Function.prototype, 'onceStrict', {
-    value: function () {
-      return onceStrict(this)
-    },
-    configurable: true
-  })
-})
+var lib = __nccwpck_require__(4127);
 
-function once (fn) {
-  var f = function () {
-    if (f.called) return f.value
-    f.called = true
-    return f.value = fn.apply(this, arguments)
+var _require = __nccwpck_require__(4428),
+    Environment = _require.Environment,
+    Template = _require.Template;
+
+var Loader = __nccwpck_require__(6981);
+
+var loaders = __nccwpck_require__(4395);
+
+var precompile = __nccwpck_require__(7513);
+
+var compiler = __nccwpck_require__(4548);
+
+var parser = __nccwpck_require__(6614);
+
+var lexer = __nccwpck_require__(3158);
+
+var runtime = __nccwpck_require__(1998);
+
+var nodes = __nccwpck_require__(429);
+
+var installJinjaCompat = __nccwpck_require__(6976); // A single instance of an environment, since this is so commonly used
+
+
+var e;
+
+function configure(templatesPath, opts) {
+  opts = opts || {};
+
+  if (lib.isObject(templatesPath)) {
+    opts = templatesPath;
+    templatesPath = null;
   }
-  f.called = false
-  return f
-}
 
-function onceStrict (fn) {
-  var f = function () {
-    if (f.called)
-      throw new Error(f.onceError)
-    f.called = true
-    return f.value = fn.apply(this, arguments)
+  var TemplateLoader;
+
+  if (loaders.FileSystemLoader) {
+    TemplateLoader = new loaders.FileSystemLoader(templatesPath, {
+      watch: opts.watch,
+      noCache: opts.noCache
+    });
+  } else if (loaders.WebLoader) {
+    TemplateLoader = new loaders.WebLoader(templatesPath, {
+      useCache: opts.web && opts.web.useCache,
+      async: opts.web && opts.web.async
+    });
   }
-  var name = fn.name || 'Function wrapped with `once`'
-  f.onceError = name + " shouldn't be called more than once"
-  f.called = false
-  return f
+
+  e = new Environment(TemplateLoader, opts);
+
+  if (opts && opts.express) {
+    e.express(opts.express);
+  }
+
+  return e;
 }
 
+module.exports = {
+  Environment: Environment,
+  Template: Template,
+  Loader: Loader,
+  FileSystemLoader: loaders.FileSystemLoader,
+  NodeResolveLoader: loaders.NodeResolveLoader,
+  PrecompiledLoader: loaders.PrecompiledLoader,
+  WebLoader: loaders.WebLoader,
+  compiler: compiler,
+  parser: parser,
+  lexer: lexer,
+  runtime: runtime,
+  lib: lib,
+  nodes: nodes,
+  installJinjaCompat: installJinjaCompat,
+  configure: configure,
+  reset: function reset() {
+    e = undefined;
+  },
+  compile: function compile(src, env, path, eagerCompile) {
+    if (!e) {
+      configure();
+    }
+
+    return new Template(src, env, path, eagerCompile);
+  },
+  render: function render(name, ctx, cb) {
+    if (!e) {
+      configure();
+    }
+
+    return e.render(name, ctx, cb);
+  },
+  renderString: function renderString(src, ctx, cb) {
+    if (!e) {
+      configure();
+    }
+
+    return e.renderString(src, ctx, cb);
+  },
+  precompile: precompile ? precompile.precompile : undefined,
+  precompileString: precompile ? precompile.precompileString : undefined
+};
 
 /***/ }),
 
-/***/ 4256:
+/***/ 4548:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 "use strict";
 
 
-var punycode = __nccwpck_require__(5477);
-var mappingTable = __nccwpck_require__(2020);
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
 
-var PROCESSING_OPTIONS = {
-  TRANSITIONAL: 0,
-  NONTRANSITIONAL: 1
-};
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 
-function normalize(str) { // fix bug in v8
-  return str.split('\u0000').map(function (s) { return s.normalize('NFC'); }).join('\u0000');
-}
+var parser = __nccwpck_require__(6614);
 
-function findStatus(val) {
-  var start = 0;
-  var end = mappingTable.length - 1;
+var transformer = __nccwpck_require__(3773);
 
-  while (start <= end) {
-    var mid = Math.floor((start + end) / 2);
+var nodes = __nccwpck_require__(429);
 
-    var target = mappingTable[mid];
-    if (target[0][0] <= val && target[0][1] >= val) {
-      return target;
-    } else if (target[0][0] > val) {
-      end = mid - 1;
-    } else {
-      start = mid + 1;
-    }
-  }
+var _require = __nccwpck_require__(4127),
+    TemplateError = _require.TemplateError;
 
-  return null;
-}
+var _require2 = __nccwpck_require__(1998),
+    Frame = _require2.Frame;
 
-var regexAstralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+var _require3 = __nccwpck_require__(7007),
+    Obj = _require3.Obj; // These are all the same for now, but shouldn't be passed straight
+// through
 
-function countSymbols(string) {
-  return string
-    // replace every surrogate pair with a BMP symbol
-    .replace(regexAstralSymbols, '_')
-    // then get the length
-    .length;
-}
 
-function mapChars(domain_name, useSTD3, processing_option) {
-  var hasError = false;
-  var processed = "";
+var compareOps = {
+  '==': '==',
+  '===': '===',
+  '!=': '!=',
+  '!==': '!==',
+  '<': '<',
+  '>': '>',
+  '<=': '<=',
+  '>=': '>='
+};
 
-  var len = countSymbols(domain_name);
-  for (var i = 0; i < len; ++i) {
-    var codePoint = domain_name.codePointAt(i);
-    var status = findStatus(codePoint);
+var Compiler = /*#__PURE__*/function (_Obj) {
+  _inheritsLoose(Compiler, _Obj);
 
-    switch (status[1]) {
-      case "disallowed":
-        hasError = true;
-        processed += String.fromCodePoint(codePoint);
-        break;
-      case "ignored":
-        break;
-      case "mapped":
-        processed += String.fromCodePoint.apply(String, status[2]);
-        break;
-      case "deviation":
-        if (processing_option === PROCESSING_OPTIONS.TRANSITIONAL) {
-          processed += String.fromCodePoint.apply(String, status[2]);
-        } else {
-          processed += String.fromCodePoint(codePoint);
+  function Compiler() {
+    return _Obj.apply(this, arguments) || this;
+  }
+
+  var _proto = Compiler.prototype;
+
+  _proto.init = function init(templateName, throwOnUndefined) {
+    this.templateName = templateName;
+    this.codebuf = [];
+    this.lastId = 0;
+    this.buffer = null;
+    this.bufferStack = [];
+    this._scopeClosers = '';
+    this.inBlock = false;
+    this.throwOnUndefined = throwOnUndefined;
+  };
+
+  _proto.fail = function fail(msg, lineno, colno) {
+    if (lineno !== undefined) {
+      lineno += 1;
+    }
+
+    if (colno !== undefined) {
+      colno += 1;
+    }
+
+    throw new TemplateError(msg, lineno, colno);
+  };
+
+  _proto._pushBuffer = function _pushBuffer() {
+    var id = this._tmpid();
+
+    this.bufferStack.push(this.buffer);
+    this.buffer = id;
+
+    this._emit("var " + this.buffer + " = \"\";");
+
+    return id;
+  };
+
+  _proto._popBuffer = function _popBuffer() {
+    this.buffer = this.bufferStack.pop();
+  };
+
+  _proto._emit = function _emit(code) {
+    this.codebuf.push(code);
+  };
+
+  _proto._emitLine = function _emitLine(code) {
+    this._emit(code + '\n');
+  };
+
+  _proto._emitLines = function _emitLines() {
+    var _this = this;
+
+    for (var _len = arguments.length, lines = new Array(_len), _key = 0; _key < _len; _key++) {
+      lines[_key] = arguments[_key];
+    }
+
+    lines.forEach(function (line) {
+      return _this._emitLine(line);
+    });
+  };
+
+  _proto._emitFuncBegin = function _emitFuncBegin(node, name) {
+    this.buffer = 'output';
+    this._scopeClosers = '';
+
+    this._emitLine("function " + name + "(env, context, frame, runtime, cb) {");
+
+    this._emitLine("var lineno = " + node.lineno + ";");
+
+    this._emitLine("var colno = " + node.colno + ";");
+
+    this._emitLine("var " + this.buffer + " = \"\";");
+
+    this._emitLine('try {');
+  };
+
+  _proto._emitFuncEnd = function _emitFuncEnd(noReturn) {
+    if (!noReturn) {
+      this._emitLine('cb(null, ' + this.buffer + ');');
+    }
+
+    this._closeScopeLevels();
+
+    this._emitLine('} catch (e) {');
+
+    this._emitLine('  cb(runtime.handleError(e, lineno, colno));');
+
+    this._emitLine('}');
+
+    this._emitLine('}');
+
+    this.buffer = null;
+  };
+
+  _proto._addScopeLevel = function _addScopeLevel() {
+    this._scopeClosers += '})';
+  };
+
+  _proto._closeScopeLevels = function _closeScopeLevels() {
+    this._emitLine(this._scopeClosers + ';');
+
+    this._scopeClosers = '';
+  };
+
+  _proto._withScopedSyntax = function _withScopedSyntax(func) {
+    var _scopeClosers = this._scopeClosers;
+    this._scopeClosers = '';
+    func.call(this);
+
+    this._closeScopeLevels();
+
+    this._scopeClosers = _scopeClosers;
+  };
+
+  _proto._makeCallback = function _makeCallback(res) {
+    var err = this._tmpid();
+
+    return 'function(' + err + (res ? ',' + res : '') + ') {\n' + 'if(' + err + ') { cb(' + err + '); return; }';
+  };
+
+  _proto._tmpid = function _tmpid() {
+    this.lastId++;
+    return 't_' + this.lastId;
+  };
+
+  _proto._templateName = function _templateName() {
+    return this.templateName == null ? 'undefined' : JSON.stringify(this.templateName);
+  };
+
+  _proto._compileChildren = function _compileChildren(node, frame) {
+    var _this2 = this;
+
+    node.children.forEach(function (child) {
+      _this2.compile(child, frame);
+    });
+  };
+
+  _proto._compileAggregate = function _compileAggregate(node, frame, startChar, endChar) {
+    var _this3 = this;
+
+    if (startChar) {
+      this._emit(startChar);
+    }
+
+    node.children.forEach(function (child, i) {
+      if (i > 0) {
+        _this3._emit(',');
+      }
+
+      _this3.compile(child, frame);
+    });
+
+    if (endChar) {
+      this._emit(endChar);
+    }
+  };
+
+  _proto._compileExpression = function _compileExpression(node, frame) {
+    // TODO: I'm not really sure if this type check is worth it or
+    // not.
+    this.assertType(node, nodes.Literal, nodes.Symbol, nodes.Group, nodes.Array, nodes.Dict, nodes.FunCall, nodes.Caller, nodes.Filter, nodes.LookupVal, nodes.Compare, nodes.InlineIf, nodes.In, nodes.Is, nodes.And, nodes.Or, nodes.Not, nodes.Add, nodes.Concat, nodes.Sub, nodes.Mul, nodes.Div, nodes.FloorDiv, nodes.Mod, nodes.Pow, nodes.Neg, nodes.Pos, nodes.Compare, nodes.NodeList);
+    this.compile(node, frame);
+  };
+
+  _proto.assertType = function assertType(node) {
+    for (var _len2 = arguments.length, types = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+      types[_key2 - 1] = arguments[_key2];
+    }
+
+    if (!types.some(function (t) {
+      return node instanceof t;
+    })) {
+      this.fail("assertType: invalid type: " + node.typename, node.lineno, node.colno);
+    }
+  };
+
+  _proto.compileCallExtension = function compileCallExtension(node, frame, async) {
+    var _this4 = this;
+
+    var args = node.args;
+    var contentArgs = node.contentArgs;
+    var autoescape = typeof node.autoescape === 'boolean' ? node.autoescape : true;
+
+    if (!async) {
+      this._emit(this.buffer + " += runtime.suppressValue(");
+    }
+
+    this._emit("env.getExtension(\"" + node.extName + "\")[\"" + node.prop + "\"](");
+
+    this._emit('context');
+
+    if (args || contentArgs) {
+      this._emit(',');
+    }
+
+    if (args) {
+      if (!(args instanceof nodes.NodeList)) {
+        this.fail('compileCallExtension: arguments must be a NodeList, ' + 'use `parser.parseSignature`');
+      }
+
+      args.children.forEach(function (arg, i) {
+        // Tag arguments are passed normally to the call. Note
+        // that keyword arguments are turned into a single js
+        // object as the last argument, if they exist.
+        _this4._compileExpression(arg, frame);
+
+        if (i !== args.children.length - 1 || contentArgs.length) {
+          _this4._emit(',');
         }
-        break;
-      case "valid":
-        processed += String.fromCodePoint(codePoint);
-        break;
-      case "disallowed_STD3_mapped":
-        if (useSTD3) {
-          hasError = true;
-          processed += String.fromCodePoint(codePoint);
-        } else {
-          processed += String.fromCodePoint.apply(String, status[2]);
+      });
+    }
+
+    if (contentArgs.length) {
+      contentArgs.forEach(function (arg, i) {
+        if (i > 0) {
+          _this4._emit(',');
         }
-        break;
-      case "disallowed_STD3_valid":
-        if (useSTD3) {
-          hasError = true;
+
+        if (arg) {
+          _this4._emitLine('function(cb) {');
+
+          _this4._emitLine('if(!cb) { cb = function(err) { if(err) { throw err; }}}');
+
+          var id = _this4._pushBuffer();
+
+          _this4._withScopedSyntax(function () {
+            _this4.compile(arg, frame);
+
+            _this4._emitLine("cb(null, " + id + ");");
+          });
+
+          _this4._popBuffer();
+
+          _this4._emitLine("return " + id + ";");
+
+          _this4._emitLine('}');
+        } else {
+          _this4._emit('null');
         }
+      });
+    }
+
+    if (async) {
+      var res = this._tmpid();
+
+      this._emitLine(', ' + this._makeCallback(res));
+
+      this._emitLine(this.buffer + " += runtime.suppressValue(" + res + ", " + autoescape + " && env.opts.autoescape);");
+
+      this._addScopeLevel();
+    } else {
+      this._emit(')');
+
+      this._emit(", " + autoescape + " && env.opts.autoescape);\n");
+    }
+  };
+
+  _proto.compileCallExtensionAsync = function compileCallExtensionAsync(node, frame) {
+    this.compileCallExtension(node, frame, true);
+  };
+
+  _proto.compileNodeList = function compileNodeList(node, frame) {
+    this._compileChildren(node, frame);
+  };
+
+  _proto.compileLiteral = function compileLiteral(node) {
+    if (typeof node.value === 'string') {
+      var val = node.value.replace(/\\/g, '\\\\');
+      val = val.replace(/"/g, '\\"');
+      val = val.replace(/\n/g, '\\n');
+      val = val.replace(/\r/g, '\\r');
+      val = val.replace(/\t/g, '\\t');
+      val = val.replace(/\u2028/g, "\\u2028");
+
+      this._emit("\"" + val + "\"");
+    } else if (node.value === null) {
+      this._emit('null');
+    } else {
+      this._emit(node.value.toString());
+    }
+  };
+
+  _proto.compileSymbol = function compileSymbol(node, frame) {
+    var name = node.value;
+    var v = frame.lookup(name);
+
+    if (v) {
+      this._emit(v);
+    } else {
+      this._emit('runtime.contextOrFrameLookup(' + 'context, frame, "' + name + '")');
+    }
+  };
+
+  _proto.compileGroup = function compileGroup(node, frame) {
+    this._compileAggregate(node, frame, '(', ')');
+  };
+
+  _proto.compileArray = function compileArray(node, frame) {
+    this._compileAggregate(node, frame, '[', ']');
+  };
+
+  _proto.compileDict = function compileDict(node, frame) {
+    this._compileAggregate(node, frame, '{', '}');
+  };
+
+  _proto.compilePair = function compilePair(node, frame) {
+    var key = node.key;
+    var val = node.value;
+
+    if (key instanceof nodes.Symbol) {
+      key = new nodes.Literal(key.lineno, key.colno, key.value);
+    } else if (!(key instanceof nodes.Literal && typeof key.value === 'string')) {
+      this.fail('compilePair: Dict keys must be strings or names', key.lineno, key.colno);
+    }
+
+    this.compile(key, frame);
+
+    this._emit(': ');
+
+    this._compileExpression(val, frame);
+  };
+
+  _proto.compileInlineIf = function compileInlineIf(node, frame) {
+    this._emit('(');
+
+    this.compile(node.cond, frame);
+
+    this._emit('?');
+
+    this.compile(node.body, frame);
+
+    this._emit(':');
+
+    if (node.else_ !== null) {
+      this.compile(node.else_, frame);
+    } else {
+      this._emit('""');
+    }
+
+    this._emit(')');
+  };
+
+  _proto.compileIn = function compileIn(node, frame) {
+    this._emit('runtime.inOperator(');
+
+    this.compile(node.left, frame);
+
+    this._emit(',');
+
+    this.compile(node.right, frame);
+
+    this._emit(')');
+  };
+
+  _proto.compileIs = function compileIs(node, frame) {
+    // first, we need to try to get the name of the test function, if it's a
+    // callable (i.e., has args) and not a symbol.
+    var right = node.right.name ? node.right.name.value // otherwise go with the symbol value
+    : node.right.value;
+
+    this._emit('env.getTest("' + right + '").call(context, ');
+
+    this.compile(node.left, frame); // compile the arguments for the callable if they exist
+
+    if (node.right.args) {
+      this._emit(',');
+
+      this.compile(node.right.args, frame);
+    }
+
+    this._emit(') === true');
+  };
+
+  _proto._binOpEmitter = function _binOpEmitter(node, frame, str) {
+    this.compile(node.left, frame);
+
+    this._emit(str);
+
+    this.compile(node.right, frame);
+  } // ensure concatenation instead of addition
+  // by adding empty string in between
+  ;
+
+  _proto.compileOr = function compileOr(node, frame) {
+    return this._binOpEmitter(node, frame, ' || ');
+  };
+
+  _proto.compileAnd = function compileAnd(node, frame) {
+    return this._binOpEmitter(node, frame, ' && ');
+  };
+
+  _proto.compileAdd = function compileAdd(node, frame) {
+    return this._binOpEmitter(node, frame, ' + ');
+  };
+
+  _proto.compileConcat = function compileConcat(node, frame) {
+    return this._binOpEmitter(node, frame, ' + "" + ');
+  };
+
+  _proto.compileSub = function compileSub(node, frame) {
+    return this._binOpEmitter(node, frame, ' - ');
+  };
+
+  _proto.compileMul = function compileMul(node, frame) {
+    return this._binOpEmitter(node, frame, ' * ');
+  };
+
+  _proto.compileDiv = function compileDiv(node, frame) {
+    return this._binOpEmitter(node, frame, ' / ');
+  };
+
+  _proto.compileMod = function compileMod(node, frame) {
+    return this._binOpEmitter(node, frame, ' % ');
+  };
+
+  _proto.compileNot = function compileNot(node, frame) {
+    this._emit('!');
+
+    this.compile(node.target, frame);
+  };
+
+  _proto.compileFloorDiv = function compileFloorDiv(node, frame) {
+    this._emit('Math.floor(');
+
+    this.compile(node.left, frame);
+
+    this._emit(' / ');
+
+    this.compile(node.right, frame);
+
+    this._emit(')');
+  };
+
+  _proto.compilePow = function compilePow(node, frame) {
+    this._emit('Math.pow(');
+
+    this.compile(node.left, frame);
+
+    this._emit(', ');
+
+    this.compile(node.right, frame);
+
+    this._emit(')');
+  };
+
+  _proto.compileNeg = function compileNeg(node, frame) {
+    this._emit('-');
+
+    this.compile(node.target, frame);
+  };
+
+  _proto.compilePos = function compilePos(node, frame) {
+    this._emit('+');
+
+    this.compile(node.target, frame);
+  };
+
+  _proto.compileCompare = function compileCompare(node, frame) {
+    var _this5 = this;
+
+    this.compile(node.expr, frame);
+    node.ops.forEach(function (op) {
+      _this5._emit(" " + compareOps[op.type] + " ");
+
+      _this5.compile(op.expr, frame);
+    });
+  };
+
+  _proto.compileLookupVal = function compileLookupVal(node, frame) {
+    this._emit('runtime.memberLookup((');
+
+    this._compileExpression(node.target, frame);
+
+    this._emit('),');
+
+    this._compileExpression(node.val, frame);
+
+    this._emit(')');
+  };
+
+  _proto._getNodeName = function _getNodeName(node) {
+    switch (node.typename) {
+      case 'Symbol':
+        return node.value;
+
+      case 'FunCall':
+        return 'the return value of (' + this._getNodeName(node.name) + ')';
+
+      case 'LookupVal':
+        return this._getNodeName(node.target) + '["' + this._getNodeName(node.val) + '"]';
+
+      case 'Literal':
+        return node.value.toString();
+
+      default:
+        return '--expression--';
+    }
+  };
+
+  _proto.compileFunCall = function compileFunCall(node, frame) {
+    // Keep track of line/col info at runtime by settings
+    // variables within an expression. An expression in javascript
+    // like (x, y, z) returns the last value, and x and y can be
+    // anything
+    this._emit('(lineno = ' + node.lineno + ', colno = ' + node.colno + ', ');
+
+    this._emit('runtime.callWrap('); // Compile it as normal.
+
+
+    this._compileExpression(node.name, frame); // Output the name of what we're calling so we can get friendly errors
+    // if the lookup fails.
+
+
+    this._emit(', "' + this._getNodeName(node.name).replace(/"/g, '\\"') + '", context, ');
+
+    this._compileAggregate(node.args, frame, '[', '])');
+
+    this._emit(')');
+  };
+
+  _proto.compileFilter = function compileFilter(node, frame) {
+    var name = node.name;
+    this.assertType(name, nodes.Symbol);
+
+    this._emit('env.getFilter("' + name.value + '").call(context, ');
+
+    this._compileAggregate(node.args, frame);
+
+    this._emit(')');
+  };
+
+  _proto.compileFilterAsync = function compileFilterAsync(node, frame) {
+    var name = node.name;
+    var symbol = node.symbol.value;
+    this.assertType(name, nodes.Symbol);
+    frame.set(symbol, symbol);
+
+    this._emit('env.getFilter("' + name.value + '").call(context, ');
+
+    this._compileAggregate(node.args, frame);
+
+    this._emitLine(', ' + this._makeCallback(symbol));
+
+    this._addScopeLevel();
+  };
+
+  _proto.compileKeywordArgs = function compileKeywordArgs(node, frame) {
+    this._emit('runtime.makeKeywordArgs(');
+
+    this.compileDict(node, frame);
+
+    this._emit(')');
+  };
+
+  _proto.compileSet = function compileSet(node, frame) {
+    var _this6 = this;
+
+    var ids = []; // Lookup the variable names for each identifier and create
+    // new ones if necessary
+
+    node.targets.forEach(function (target) {
+      var name = target.value;
+      var id = frame.lookup(name);
+
+      if (id === null || id === undefined) {
+        id = _this6._tmpid(); // Note: This relies on js allowing scope across
+        // blocks, in case this is created inside an `if`
+
+        _this6._emitLine('var ' + id + ';');
+      }
+
+      ids.push(id);
+    });
+
+    if (node.value) {
+      this._emit(ids.join(' = ') + ' = ');
+
+      this._compileExpression(node.value, frame);
+
+      this._emitLine(';');
+    } else {
+      this._emit(ids.join(' = ') + ' = ');
+
+      this.compile(node.body, frame);
+
+      this._emitLine(';');
+    }
+
+    node.targets.forEach(function (target, i) {
+      var id = ids[i];
+      var name = target.value; // We are running this for every var, but it's very
+      // uncommon to assign to multiple vars anyway
+
+      _this6._emitLine("frame.set(\"" + name + "\", " + id + ", true);");
+
+      _this6._emitLine('if(frame.topLevel) {');
+
+      _this6._emitLine("context.setVariable(\"" + name + "\", " + id + ");");
+
+      _this6._emitLine('}');
+
+      if (name.charAt(0) !== '_') {
+        _this6._emitLine('if(frame.topLevel) {');
+
+        _this6._emitLine("context.addExport(\"" + name + "\", " + id + ");");
+
+        _this6._emitLine('}');
+      }
+    });
+  };
+
+  _proto.compileSwitch = function compileSwitch(node, frame) {
+    var _this7 = this;
+
+    this._emit('switch (');
+
+    this.compile(node.expr, frame);
+
+    this._emit(') {');
+
+    node.cases.forEach(function (c, i) {
+      _this7._emit('case ');
+
+      _this7.compile(c.cond, frame);
+
+      _this7._emit(': ');
+
+      _this7.compile(c.body, frame); // preserve fall-throughs
+
+
+      if (c.body.children.length) {
+        _this7._emitLine('break;');
+      }
+    });
+
+    if (node.default) {
+      this._emit('default:');
+
+      this.compile(node.default, frame);
+    }
+
+    this._emit('}');
+  };
+
+  _proto.compileIf = function compileIf(node, frame, async) {
+    var _this8 = this;
+
+    this._emit('if(');
+
+    this._compileExpression(node.cond, frame);
+
+    this._emitLine(') {');
+
+    this._withScopedSyntax(function () {
+      _this8.compile(node.body, frame);
+
+      if (async) {
+        _this8._emit('cb()');
+      }
+    });
+
+    if (node.else_) {
+      this._emitLine('}\nelse {');
+
+      this._withScopedSyntax(function () {
+        _this8.compile(node.else_, frame);
+
+        if (async) {
+          _this8._emit('cb()');
+        }
+      });
+    } else if (async) {
+      this._emitLine('}\nelse {');
+
+      this._emit('cb()');
+    }
+
+    this._emitLine('}');
+  };
+
+  _proto.compileIfAsync = function compileIfAsync(node, frame) {
+    this._emit('(function(cb) {');
+
+    this.compileIf(node, frame, true);
+
+    this._emit('})(' + this._makeCallback());
+
+    this._addScopeLevel();
+  };
+
+  _proto._emitLoopBindings = function _emitLoopBindings(node, arr, i, len) {
+    var _this9 = this;
+
+    var bindings = [{
+      name: 'index',
+      val: i + " + 1"
+    }, {
+      name: 'index0',
+      val: i
+    }, {
+      name: 'revindex',
+      val: len + " - " + i
+    }, {
+      name: 'revindex0',
+      val: len + " - " + i + " - 1"
+    }, {
+      name: 'first',
+      val: i + " === 0"
+    }, {
+      name: 'last',
+      val: i + " === " + len + " - 1"
+    }, {
+      name: 'length',
+      val: len
+    }];
+    bindings.forEach(function (b) {
+      _this9._emitLine("frame.set(\"loop." + b.name + "\", " + b.val + ");");
+    });
+  };
+
+  _proto.compileFor = function compileFor(node, frame) {
+    var _this10 = this;
+
+    // Some of this code is ugly, but it keeps the generated code
+    // as fast as possible. ForAsync also shares some of this, but
+    // not much.
+    var i = this._tmpid();
+
+    var len = this._tmpid();
+
+    var arr = this._tmpid();
+
+    frame = frame.push();
+
+    this._emitLine('frame = frame.push();');
+
+    this._emit("var " + arr + " = ");
+
+    this._compileExpression(node.arr, frame);
+
+    this._emitLine(';');
+
+    this._emit("if(" + arr + ") {");
+
+    this._emitLine(arr + ' = runtime.fromIterator(' + arr + ');'); // If multiple names are passed, we need to bind them
+    // appropriately
+
+
+    if (node.name instanceof nodes.Array) {
+      this._emitLine("var " + i + ";"); // The object could be an arroy or object. Note that the
+      // body of the loop is duplicated for each condition, but
+      // we are optimizing for speed over size.
+
+
+      this._emitLine("if(runtime.isArray(" + arr + ")) {");
+
+      this._emitLine("var " + len + " = " + arr + ".length;");
+
+      this._emitLine("for(" + i + "=0; " + i + " < " + arr + ".length; " + i + "++) {"); // Bind each declared var
+
+
+      node.name.children.forEach(function (child, u) {
+        var tid = _this10._tmpid();
+
+        _this10._emitLine("var " + tid + " = " + arr + "[" + i + "][" + u + "];");
+
+        _this10._emitLine("frame.set(\"" + child + "\", " + arr + "[" + i + "][" + u + "]);");
+
+        frame.set(node.name.children[u].value, tid);
+      });
+
+      this._emitLoopBindings(node, arr, i, len);
+
+      this._withScopedSyntax(function () {
+        _this10.compile(node.body, frame);
+      });
+
+      this._emitLine('}');
+
+      this._emitLine('} else {'); // Iterate over the key/values of an object
+
+
+      var _node$name$children = node.name.children,
+          key = _node$name$children[0],
+          val = _node$name$children[1];
+
+      var k = this._tmpid();
+
+      var v = this._tmpid();
+
+      frame.set(key.value, k);
+      frame.set(val.value, v);
+
+      this._emitLine(i + " = -1;");
+
+      this._emitLine("var " + len + " = runtime.keys(" + arr + ").length;");
+
+      this._emitLine("for(var " + k + " in " + arr + ") {");
+
+      this._emitLine(i + "++;");
+
+      this._emitLine("var " + v + " = " + arr + "[" + k + "];");
+
+      this._emitLine("frame.set(\"" + key.value + "\", " + k + ");");
+
+      this._emitLine("frame.set(\"" + val.value + "\", " + v + ");");
+
+      this._emitLoopBindings(node, arr, i, len);
+
+      this._withScopedSyntax(function () {
+        _this10.compile(node.body, frame);
+      });
+
+      this._emitLine('}');
+
+      this._emitLine('}');
+    } else {
+      // Generate a typical array iteration
+      var _v = this._tmpid();
+
+      frame.set(node.name.value, _v);
+
+      this._emitLine("var " + len + " = " + arr + ".length;");
+
+      this._emitLine("for(var " + i + "=0; " + i + " < " + arr + ".length; " + i + "++) {");
+
+      this._emitLine("var " + _v + " = " + arr + "[" + i + "];");
+
+      this._emitLine("frame.set(\"" + node.name.value + "\", " + _v + ");");
+
+      this._emitLoopBindings(node, arr, i, len);
+
+      this._withScopedSyntax(function () {
+        _this10.compile(node.body, frame);
+      });
+
+      this._emitLine('}');
+    }
+
+    this._emitLine('}');
+
+    if (node.else_) {
+      this._emitLine('if (!' + len + ') {');
+
+      this.compile(node.else_, frame);
+
+      this._emitLine('}');
+    }
+
+    this._emitLine('frame = frame.pop();');
+  };
+
+  _proto._compileAsyncLoop = function _compileAsyncLoop(node, frame, parallel) {
+    var _this11 = this;
+
+    // This shares some code with the For tag, but not enough to
+    // worry about. This iterates across an object asynchronously,
+    // but not in parallel.
+    var i = this._tmpid();
+
+    var len = this._tmpid();
+
+    var arr = this._tmpid();
+
+    var asyncMethod = parallel ? 'asyncAll' : 'asyncEach';
+    frame = frame.push();
+
+    this._emitLine('frame = frame.push();');
+
+    this._emit('var ' + arr + ' = runtime.fromIterator(');
+
+    this._compileExpression(node.arr, frame);
+
+    this._emitLine(');');
+
+    if (node.name instanceof nodes.Array) {
+      var arrayLen = node.name.children.length;
+
+      this._emit("runtime." + asyncMethod + "(" + arr + ", " + arrayLen + ", function(");
+
+      node.name.children.forEach(function (name) {
+        _this11._emit(name.value + ",");
+      });
+
+      this._emit(i + ',' + len + ',next) {');
+
+      node.name.children.forEach(function (name) {
+        var id = name.value;
+        frame.set(id, id);
+
+        _this11._emitLine("frame.set(\"" + id + "\", " + id + ");");
+      });
+    } else {
+      var id = node.name.value;
+
+      this._emitLine("runtime." + asyncMethod + "(" + arr + ", 1, function(" + id + ", " + i + ", " + len + ",next) {");
+
+      this._emitLine('frame.set("' + id + '", ' + id + ');');
+
+      frame.set(id, id);
+    }
+
+    this._emitLoopBindings(node, arr, i, len);
+
+    this._withScopedSyntax(function () {
+      var buf;
+
+      if (parallel) {
+        buf = _this11._pushBuffer();
+      }
+
+      _this11.compile(node.body, frame);
+
+      _this11._emitLine('next(' + i + (buf ? ',' + buf : '') + ');');
+
+      if (parallel) {
+        _this11._popBuffer();
+      }
+    });
+
+    var output = this._tmpid();
+
+    this._emitLine('}, ' + this._makeCallback(output));
+
+    this._addScopeLevel();
+
+    if (parallel) {
+      this._emitLine(this.buffer + ' += ' + output + ';');
+    }
+
+    if (node.else_) {
+      this._emitLine('if (!' + arr + '.length) {');
+
+      this.compile(node.else_, frame);
+
+      this._emitLine('}');
+    }
+
+    this._emitLine('frame = frame.pop();');
+  };
+
+  _proto.compileAsyncEach = function compileAsyncEach(node, frame) {
+    this._compileAsyncLoop(node, frame);
+  };
+
+  _proto.compileAsyncAll = function compileAsyncAll(node, frame) {
+    this._compileAsyncLoop(node, frame, true);
+  };
+
+  _proto._compileMacro = function _compileMacro(node, frame) {
+    var _this12 = this;
+
+    var args = [];
+    var kwargs = null;
+
+    var funcId = 'macro_' + this._tmpid();
+
+    var keepFrame = frame !== undefined; // Type check the definition of the args
+
+    node.args.children.forEach(function (arg, i) {
+      if (i === node.args.children.length - 1 && arg instanceof nodes.Dict) {
+        kwargs = arg;
+      } else {
+        _this12.assertType(arg, nodes.Symbol);
+
+        args.push(arg);
+      }
+    });
+    var realNames = [].concat(args.map(function (n) {
+      return "l_" + n.value;
+    }), ['kwargs']); // Quoted argument names
+
+    var argNames = args.map(function (n) {
+      return "\"" + n.value + "\"";
+    });
+    var kwargNames = (kwargs && kwargs.children || []).map(function (n) {
+      return "\"" + n.key.value + "\"";
+    }); // We pass a function to makeMacro which destructures the
+    // arguments so support setting positional args with keywords
+    // args and passing keyword args as positional args
+    // (essentially default values). See runtime.js.
+
+    var currFrame;
+
+    if (keepFrame) {
+      currFrame = frame.push(true);
+    } else {
+      currFrame = new Frame();
+    }
+
+    this._emitLines("var " + funcId + " = runtime.makeMacro(", "[" + argNames.join(', ') + "], ", "[" + kwargNames.join(', ') + "], ", "function (" + realNames.join(', ') + ") {", 'var callerFrame = frame;', 'frame = ' + (keepFrame ? 'frame.push(true);' : 'new runtime.Frame();'), 'kwargs = kwargs || {};', 'if (Object.prototype.hasOwnProperty.call(kwargs, "caller")) {', 'frame.set("caller", kwargs.caller); }'); // Expose the arguments to the template. Don't need to use
+    // random names because the function
+    // will create a new run-time scope for us
+
+
+    args.forEach(function (arg) {
+      _this12._emitLine("frame.set(\"" + arg.value + "\", l_" + arg.value + ");");
+
+      currFrame.set(arg.value, "l_" + arg.value);
+    }); // Expose the keyword arguments
+
+    if (kwargs) {
+      kwargs.children.forEach(function (pair) {
+        var name = pair.key.value;
+
+        _this12._emit("frame.set(\"" + name + "\", ");
+
+        _this12._emit("Object.prototype.hasOwnProperty.call(kwargs, \"" + name + "\")");
+
+        _this12._emit(" ? kwargs[\"" + name + "\"] : ");
+
+        _this12._compileExpression(pair.value, currFrame);
+
+        _this12._emit(');');
+      });
+    }
+
+    var bufferId = this._pushBuffer();
+
+    this._withScopedSyntax(function () {
+      _this12.compile(node.body, currFrame);
+    });
+
+    this._emitLine('frame = ' + (keepFrame ? 'frame.pop();' : 'callerFrame;'));
+
+    this._emitLine("return new runtime.SafeString(" + bufferId + ");");
+
+    this._emitLine('});');
+
+    this._popBuffer();
+
+    return funcId;
+  };
+
+  _proto.compileMacro = function compileMacro(node, frame) {
+    var funcId = this._compileMacro(node); // Expose the macro to the templates
+
+
+    var name = node.name.value;
+    frame.set(name, funcId);
+
+    if (frame.parent) {
+      this._emitLine("frame.set(\"" + name + "\", " + funcId + ");");
+    } else {
+      if (node.name.value.charAt(0) !== '_') {
+        this._emitLine("context.addExport(\"" + name + "\");");
+      }
+
+      this._emitLine("context.setVariable(\"" + name + "\", " + funcId + ");");
+    }
+  };
+
+  _proto.compileCaller = function compileCaller(node, frame) {
+    // basically an anonymous "macro expression"
+    this._emit('(function (){');
+
+    var funcId = this._compileMacro(node, frame);
+
+    this._emit("return " + funcId + ";})()");
+  };
+
+  _proto._compileGetTemplate = function _compileGetTemplate(node, frame, eagerCompile, ignoreMissing) {
+    var parentTemplateId = this._tmpid();
+
+    var parentName = this._templateName();
+
+    var cb = this._makeCallback(parentTemplateId);
+
+    var eagerCompileArg = eagerCompile ? 'true' : 'false';
+    var ignoreMissingArg = ignoreMissing ? 'true' : 'false';
+
+    this._emit('env.getTemplate(');
+
+    this._compileExpression(node.template, frame);
+
+    this._emitLine(", " + eagerCompileArg + ", " + parentName + ", " + ignoreMissingArg + ", " + cb);
+
+    return parentTemplateId;
+  };
+
+  _proto.compileImport = function compileImport(node, frame) {
+    var target = node.target.value;
+
+    var id = this._compileGetTemplate(node, frame, false, false);
+
+    this._addScopeLevel();
+
+    this._emitLine(id + '.getExported(' + (node.withContext ? 'context.getVariables(), frame, ' : '') + this._makeCallback(id));
+
+    this._addScopeLevel();
+
+    frame.set(target, id);
+
+    if (frame.parent) {
+      this._emitLine("frame.set(\"" + target + "\", " + id + ");");
+    } else {
+      this._emitLine("context.setVariable(\"" + target + "\", " + id + ");");
+    }
+  };
+
+  _proto.compileFromImport = function compileFromImport(node, frame) {
+    var _this13 = this;
+
+    var importedId = this._compileGetTemplate(node, frame, false, false);
+
+    this._addScopeLevel();
+
+    this._emitLine(importedId + '.getExported(' + (node.withContext ? 'context.getVariables(), frame, ' : '') + this._makeCallback(importedId));
+
+    this._addScopeLevel();
+
+    node.names.children.forEach(function (nameNode) {
+      var name;
+      var alias;
+
+      var id = _this13._tmpid();
+
+      if (nameNode instanceof nodes.Pair) {
+        name = nameNode.key.value;
+        alias = nameNode.value.value;
+      } else {
+        name = nameNode.value;
+        alias = name;
+      }
+
+      _this13._emitLine("if(Object.prototype.hasOwnProperty.call(" + importedId + ", \"" + name + "\")) {");
+
+      _this13._emitLine("var " + id + " = " + importedId + "." + name + ";");
+
+      _this13._emitLine('} else {');
+
+      _this13._emitLine("cb(new Error(\"cannot import '" + name + "'\")); return;");
+
+      _this13._emitLine('}');
+
+      frame.set(alias, id);
+
+      if (frame.parent) {
+        _this13._emitLine("frame.set(\"" + alias + "\", " + id + ");");
+      } else {
+        _this13._emitLine("context.setVariable(\"" + alias + "\", " + id + ");");
+      }
+    });
+  };
+
+  _proto.compileBlock = function compileBlock(node) {
+    var id = this._tmpid(); // If we are executing outside a block (creating a top-level
+    // block), we really don't want to execute its code because it
+    // will execute twice: once when the child template runs and
+    // again when the parent template runs. Note that blocks
+    // within blocks will *always* execute immediately *and*
+    // wherever else they are invoked (like used in a parent
+    // template). This may have behavioral differences from jinja
+    // because blocks can have side effects, but it seems like a
+    // waste of performance to always execute huge top-level
+    // blocks twice
+
+
+    if (!this.inBlock) {
+      this._emit('(parentTemplate ? function(e, c, f, r, cb) { cb(""); } : ');
+    }
+
+    this._emit("context.getBlock(\"" + node.name.value + "\")");
+
+    if (!this.inBlock) {
+      this._emit(')');
+    }
+
+    this._emitLine('(env, context, frame, runtime, ' + this._makeCallback(id));
+
+    this._emitLine(this.buffer + " += " + id + ";");
+
+    this._addScopeLevel();
+  };
+
+  _proto.compileSuper = function compileSuper(node, frame) {
+    var name = node.blockName.value;
+    var id = node.symbol.value;
+
+    var cb = this._makeCallback(id);
+
+    this._emitLine("context.getSuper(env, \"" + name + "\", b_" + name + ", frame, runtime, " + cb);
+
+    this._emitLine(id + " = runtime.markSafe(" + id + ");");
+
+    this._addScopeLevel();
+
+    frame.set(id, id);
+  };
+
+  _proto.compileExtends = function compileExtends(node, frame) {
+    var k = this._tmpid();
+
+    var parentTemplateId = this._compileGetTemplate(node, frame, true, false); // extends is a dynamic tag and can occur within a block like
+    // `if`, so if this happens we need to capture the parent
+    // template in the top-level scope
+
+
+    this._emitLine("parentTemplate = " + parentTemplateId);
+
+    this._emitLine("for(var " + k + " in parentTemplate.blocks) {");
+
+    this._emitLine("context.addBlock(" + k + ", parentTemplate.blocks[" + k + "]);");
+
+    this._emitLine('}');
+
+    this._addScopeLevel();
+  };
+
+  _proto.compileInclude = function compileInclude(node, frame) {
+    this._emitLine('var tasks = [];');
+
+    this._emitLine('tasks.push(');
+
+    this._emitLine('function(callback) {');
+
+    var id = this._compileGetTemplate(node, frame, false, node.ignoreMissing);
+
+    this._emitLine("callback(null," + id + ");});");
+
+    this._emitLine('});');
+
+    var id2 = this._tmpid();
+
+    this._emitLine('tasks.push(');
+
+    this._emitLine('function(template, callback){');
+
+    this._emitLine('template.render(context.getVariables(), frame, ' + this._makeCallback(id2));
+
+    this._emitLine('callback(null,' + id2 + ');});');
+
+    this._emitLine('});');
+
+    this._emitLine('tasks.push(');
+
+    this._emitLine('function(result, callback){');
+
+    this._emitLine(this.buffer + " += result;");
+
+    this._emitLine('callback(null);');
+
+    this._emitLine('});');
+
+    this._emitLine('env.waterfall(tasks, function(){');
+
+    this._addScopeLevel();
+  };
+
+  _proto.compileTemplateData = function compileTemplateData(node, frame) {
+    this.compileLiteral(node, frame);
+  };
+
+  _proto.compileCapture = function compileCapture(node, frame) {
+    var _this14 = this;
+
+    // we need to temporarily override the current buffer id as 'output'
+    // so the set block writes to the capture output instead of the buffer
+    var buffer = this.buffer;
+    this.buffer = 'output';
+
+    this._emitLine('(function() {');
+
+    this._emitLine('var output = "";');
+
+    this._withScopedSyntax(function () {
+      _this14.compile(node.body, frame);
+    });
+
+    this._emitLine('return output;');
+
+    this._emitLine('})()'); // and of course, revert back to the old buffer id
+
+
+    this.buffer = buffer;
+  };
+
+  _proto.compileOutput = function compileOutput(node, frame) {
+    var _this15 = this;
+
+    var children = node.children;
+    children.forEach(function (child) {
+      // TemplateData is a special case because it is never
+      // autoescaped, so simply output it for optimization
+      if (child instanceof nodes.TemplateData) {
+        if (child.value) {
+          _this15._emit(_this15.buffer + " += ");
+
+          _this15.compileLiteral(child, frame);
+
+          _this15._emitLine(';');
+        }
+      } else {
+        _this15._emit(_this15.buffer + " += runtime.suppressValue(");
+
+        if (_this15.throwOnUndefined) {
+          _this15._emit('runtime.ensureDefined(');
+        }
+
+        _this15.compile(child, frame);
+
+        if (_this15.throwOnUndefined) {
+          _this15._emit("," + node.lineno + "," + node.colno + ")");
+        }
+
+        _this15._emit(', env.opts.autoescape);\n');
+      }
+    });
+  };
+
+  _proto.compileRoot = function compileRoot(node, frame) {
+    var _this16 = this;
+
+    if (frame) {
+      this.fail('compileRoot: root node can\'t have frame');
+    }
+
+    frame = new Frame();
+
+    this._emitFuncBegin(node, 'root');
+
+    this._emitLine('var parentTemplate = null;');
+
+    this._compileChildren(node, frame);
+
+    this._emitLine('if(parentTemplate) {');
+
+    this._emitLine('parentTemplate.rootRenderFunc(env, context, frame, runtime, cb);');
+
+    this._emitLine('} else {');
+
+    this._emitLine("cb(null, " + this.buffer + ");");
+
+    this._emitLine('}');
+
+    this._emitFuncEnd(true);
+
+    this.inBlock = true;
+    var blockNames = [];
+    var blocks = node.findAll(nodes.Block);
+    blocks.forEach(function (block, i) {
+      var name = block.name.value;
+
+      if (blockNames.indexOf(name) !== -1) {
+        throw new Error("Block \"" + name + "\" defined more than once.");
+      }
+
+      blockNames.push(name);
+
+      _this16._emitFuncBegin(block, "b_" + name);
+
+      var tmpFrame = new Frame();
+
+      _this16._emitLine('var frame = frame.push(true);');
+
+      _this16.compile(block.body, tmpFrame);
+
+      _this16._emitFuncEnd();
+    });
+
+    this._emitLine('return {');
+
+    blocks.forEach(function (block, i) {
+      var blockName = "b_" + block.name.value;
+
+      _this16._emitLine(blockName + ": " + blockName + ",");
+    });
+
+    this._emitLine('root: root\n};');
+  };
+
+  _proto.compile = function compile(node, frame) {
+    var _compile = this['compile' + node.typename];
+
+    if (_compile) {
+      _compile.call(this, node, frame);
+    } else {
+      this.fail("compile: Cannot compile node: " + node.typename, node.lineno, node.colno);
+    }
+  };
+
+  _proto.getCode = function getCode() {
+    return this.codebuf.join('');
+  };
+
+  return Compiler;
+}(Obj);
+
+module.exports = {
+  compile: function compile(src, asyncFilters, extensions, name, opts) {
+    if (opts === void 0) {
+      opts = {};
+    }
+
+    var c = new Compiler(name, opts.throwOnUndefined); // Run the extension preprocessors against the source.
+
+    var preprocessors = (extensions || []).map(function (ext) {
+      return ext.preprocess;
+    }).filter(function (f) {
+      return !!f;
+    });
+    var processedSrc = preprocessors.reduce(function (s, processor) {
+      return processor(s);
+    }, src);
+    c.compile(transformer.transform(parser.parse(processedSrc, extensions, opts), asyncFilters, name));
+    return c.getCode();
+  },
+  Compiler: Compiler
+};
+
+/***/ }),
+
+/***/ 4428:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+var asap = __nccwpck_require__(7943);
+
+var _waterfall = __nccwpck_require__(3980);
+
+var lib = __nccwpck_require__(4127);
+
+var compiler = __nccwpck_require__(4548);
+
+var filters = __nccwpck_require__(9223);
+
+var _require = __nccwpck_require__(4395),
+    FileSystemLoader = _require.FileSystemLoader,
+    WebLoader = _require.WebLoader,
+    PrecompiledLoader = _require.PrecompiledLoader;
+
+var tests = __nccwpck_require__(841);
+
+var globals = __nccwpck_require__(8956);
+
+var _require2 = __nccwpck_require__(7007),
+    Obj = _require2.Obj,
+    EmitterObj = _require2.EmitterObj;
+
+var globalRuntime = __nccwpck_require__(1998);
+
+var handleError = globalRuntime.handleError,
+    Frame = globalRuntime.Frame;
+
+var expressApp = __nccwpck_require__(6548); // If the user is using the async API, *always* call it
+// asynchronously even if the template was synchronous.
+
+
+function callbackAsap(cb, err, res) {
+  asap(function () {
+    cb(err, res);
+  });
+}
+/**
+ * A no-op template, for use with {% include ignore missing %}
+ */
+
+
+var noopTmplSrc = {
+  type: 'code',
+  obj: {
+    root: function root(env, context, frame, runtime, cb) {
+      try {
+        cb(null, '');
+      } catch (e) {
+        cb(handleError(e, null, null));
+      }
+    }
+  }
+};
+
+var Environment = /*#__PURE__*/function (_EmitterObj) {
+  _inheritsLoose(Environment, _EmitterObj);
+
+  function Environment() {
+    return _EmitterObj.apply(this, arguments) || this;
+  }
+
+  var _proto = Environment.prototype;
+
+  _proto.init = function init(loaders, opts) {
+    var _this = this;
+
+    // The dev flag determines the trace that'll be shown on errors.
+    // If set to true, returns the full trace from the error point,
+    // otherwise will return trace starting from Template.render
+    // (the full trace from within nunjucks may confuse developers using
+    //  the library)
+    // defaults to false
+    opts = this.opts = opts || {};
+    this.opts.dev = !!opts.dev; // The autoescape flag sets global autoescaping. If true,
+    // every string variable will be escaped by default.
+    // If false, strings can be manually escaped using the `escape` filter.
+    // defaults to true
+
+    this.opts.autoescape = opts.autoescape != null ? opts.autoescape : true; // If true, this will make the system throw errors if trying
+    // to output a null or undefined value
+
+    this.opts.throwOnUndefined = !!opts.throwOnUndefined;
+    this.opts.trimBlocks = !!opts.trimBlocks;
+    this.opts.lstripBlocks = !!opts.lstripBlocks;
+    this.loaders = [];
+
+    if (!loaders) {
+      // The filesystem loader is only available server-side
+      if (FileSystemLoader) {
+        this.loaders = [new FileSystemLoader('views')];
+      } else if (WebLoader) {
+        this.loaders = [new WebLoader('/views')];
+      }
+    } else {
+      this.loaders = lib.isArray(loaders) ? loaders : [loaders];
+    } // It's easy to use precompiled templates: just include them
+    // before you configure nunjucks and this will automatically
+    // pick it up and use it
+
+
+    if (typeof window !== 'undefined' && window.nunjucksPrecompiled) {
+      this.loaders.unshift(new PrecompiledLoader(window.nunjucksPrecompiled));
+    }
+
+    this._initLoaders();
+
+    this.globals = globals();
+    this.filters = {};
+    this.tests = {};
+    this.asyncFilters = [];
+    this.extensions = {};
+    this.extensionsList = [];
+
+    lib._entries(filters).forEach(function (_ref) {
+      var name = _ref[0],
+          filter = _ref[1];
+      return _this.addFilter(name, filter);
+    });
+
+    lib._entries(tests).forEach(function (_ref2) {
+      var name = _ref2[0],
+          test = _ref2[1];
+      return _this.addTest(name, test);
+    });
+  };
+
+  _proto._initLoaders = function _initLoaders() {
+    var _this2 = this;
+
+    this.loaders.forEach(function (loader) {
+      // Caching and cache busting
+      loader.cache = {};
+
+      if (typeof loader.on === 'function') {
+        loader.on('update', function (name, fullname) {
+          loader.cache[name] = null;
+
+          _this2.emit('update', name, fullname, loader);
+        });
+        loader.on('load', function (name, source) {
+          _this2.emit('load', name, source, loader);
+        });
+      }
+    });
+  };
+
+  _proto.invalidateCache = function invalidateCache() {
+    this.loaders.forEach(function (loader) {
+      loader.cache = {};
+    });
+  };
+
+  _proto.addExtension = function addExtension(name, extension) {
+    extension.__name = name;
+    this.extensions[name] = extension;
+    this.extensionsList.push(extension);
+    return this;
+  };
+
+  _proto.removeExtension = function removeExtension(name) {
+    var extension = this.getExtension(name);
+
+    if (!extension) {
+      return;
+    }
+
+    this.extensionsList = lib.without(this.extensionsList, extension);
+    delete this.extensions[name];
+  };
+
+  _proto.getExtension = function getExtension(name) {
+    return this.extensions[name];
+  };
+
+  _proto.hasExtension = function hasExtension(name) {
+    return !!this.extensions[name];
+  };
+
+  _proto.addGlobal = function addGlobal(name, value) {
+    this.globals[name] = value;
+    return this;
+  };
+
+  _proto.getGlobal = function getGlobal(name) {
+    if (typeof this.globals[name] === 'undefined') {
+      throw new Error('global not found: ' + name);
+    }
+
+    return this.globals[name];
+  };
+
+  _proto.addFilter = function addFilter(name, func, async) {
+    var wrapped = func;
+
+    if (async) {
+      this.asyncFilters.push(name);
+    }
+
+    this.filters[name] = wrapped;
+    return this;
+  };
+
+  _proto.getFilter = function getFilter(name) {
+    if (!this.filters[name]) {
+      throw new Error('filter not found: ' + name);
+    }
+
+    return this.filters[name];
+  };
+
+  _proto.addTest = function addTest(name, func) {
+    this.tests[name] = func;
+    return this;
+  };
+
+  _proto.getTest = function getTest(name) {
+    if (!this.tests[name]) {
+      throw new Error('test not found: ' + name);
+    }
+
+    return this.tests[name];
+  };
+
+  _proto.resolveTemplate = function resolveTemplate(loader, parentName, filename) {
+    var isRelative = loader.isRelative && parentName ? loader.isRelative(filename) : false;
+    return isRelative && loader.resolve ? loader.resolve(parentName, filename) : filename;
+  };
+
+  _proto.getTemplate = function getTemplate(name, eagerCompile, parentName, ignoreMissing, cb) {
+    var _this3 = this;
+
+    var that = this;
+    var tmpl = null;
+
+    if (name && name.raw) {
+      // this fixes autoescape for templates referenced in symbols
+      name = name.raw;
+    }
+
+    if (lib.isFunction(parentName)) {
+      cb = parentName;
+      parentName = null;
+      eagerCompile = eagerCompile || false;
+    }
+
+    if (lib.isFunction(eagerCompile)) {
+      cb = eagerCompile;
+      eagerCompile = false;
+    }
+
+    if (name instanceof Template) {
+      tmpl = name;
+    } else if (typeof name !== 'string') {
+      throw new Error('template names must be a string: ' + name);
+    } else {
+      for (var i = 0; i < this.loaders.length; i++) {
+        var loader = this.loaders[i];
+        tmpl = loader.cache[this.resolveTemplate(loader, parentName, name)];
+
+        if (tmpl) {
+          break;
+        }
+      }
+    }
+
+    if (tmpl) {
+      if (eagerCompile) {
+        tmpl.compile();
+      }
+
+      if (cb) {
+        cb(null, tmpl);
+        return undefined;
+      } else {
+        return tmpl;
+      }
+    }
+
+    var syncResult;
+
+    var createTemplate = function createTemplate(err, info) {
+      if (!info && !err && !ignoreMissing) {
+        err = new Error('template not found: ' + name);
+      }
+
+      if (err) {
+        if (cb) {
+          cb(err);
+          return;
+        } else {
+          throw err;
+        }
+      }
+
+      var newTmpl;
+
+      if (!info) {
+        newTmpl = new Template(noopTmplSrc, _this3, '', eagerCompile);
+      } else {
+        newTmpl = new Template(info.src, _this3, info.path, eagerCompile);
+
+        if (!info.noCache) {
+          info.loader.cache[name] = newTmpl;
+        }
+      }
+
+      if (cb) {
+        cb(null, newTmpl);
+      } else {
+        syncResult = newTmpl;
+      }
+    };
+
+    lib.asyncIter(this.loaders, function (loader, i, next, done) {
+      function handle(err, src) {
+        if (err) {
+          done(err);
+        } else if (src) {
+          src.loader = loader;
+          done(null, src);
+        } else {
+          next();
+        }
+      } // Resolve name relative to parentName
+
+
+      name = that.resolveTemplate(loader, parentName, name);
+
+      if (loader.async) {
+        loader.getSource(name, handle);
+      } else {
+        handle(null, loader.getSource(name));
+      }
+    }, createTemplate);
+    return syncResult;
+  };
+
+  _proto.express = function express(app) {
+    return expressApp(this, app);
+  };
+
+  _proto.render = function render(name, ctx, cb) {
+    if (lib.isFunction(ctx)) {
+      cb = ctx;
+      ctx = null;
+    } // We support a synchronous API to make it easier to migrate
+    // existing code to async. This works because if you don't do
+    // anything async work, the whole thing is actually run
+    // synchronously.
+
+
+    var syncResult = null;
+    this.getTemplate(name, function (err, tmpl) {
+      if (err && cb) {
+        callbackAsap(cb, err);
+      } else if (err) {
+        throw err;
+      } else {
+        syncResult = tmpl.render(ctx, cb);
+      }
+    });
+    return syncResult;
+  };
+
+  _proto.renderString = function renderString(src, ctx, opts, cb) {
+    if (lib.isFunction(opts)) {
+      cb = opts;
+      opts = {};
+    }
+
+    opts = opts || {};
+    var tmpl = new Template(src, this, opts.path);
+    return tmpl.render(ctx, cb);
+  };
+
+  _proto.waterfall = function waterfall(tasks, callback, forceAsync) {
+    return _waterfall(tasks, callback, forceAsync);
+  };
+
+  return Environment;
+}(EmitterObj);
+
+var Context = /*#__PURE__*/function (_Obj) {
+  _inheritsLoose(Context, _Obj);
+
+  function Context() {
+    return _Obj.apply(this, arguments) || this;
+  }
+
+  var _proto2 = Context.prototype;
+
+  _proto2.init = function init(ctx, blocks, env) {
+    var _this4 = this;
+
+    // Has to be tied to an environment so we can tap into its globals.
+    this.env = env || new Environment(); // Make a duplicate of ctx
+
+    this.ctx = lib.extend({}, ctx);
+    this.blocks = {};
+    this.exported = [];
+    lib.keys(blocks).forEach(function (name) {
+      _this4.addBlock(name, blocks[name]);
+    });
+  };
+
+  _proto2.lookup = function lookup(name) {
+    // This is one of the most called functions, so optimize for
+    // the typical case where the name isn't in the globals
+    if (name in this.env.globals && !(name in this.ctx)) {
+      return this.env.globals[name];
+    } else {
+      return this.ctx[name];
+    }
+  };
+
+  _proto2.setVariable = function setVariable(name, val) {
+    this.ctx[name] = val;
+  };
+
+  _proto2.getVariables = function getVariables() {
+    return this.ctx;
+  };
+
+  _proto2.addBlock = function addBlock(name, block) {
+    this.blocks[name] = this.blocks[name] || [];
+    this.blocks[name].push(block);
+    return this;
+  };
+
+  _proto2.getBlock = function getBlock(name) {
+    if (!this.blocks[name]) {
+      throw new Error('unknown block "' + name + '"');
+    }
+
+    return this.blocks[name][0];
+  };
+
+  _proto2.getSuper = function getSuper(env, name, block, frame, runtime, cb) {
+    var idx = lib.indexOf(this.blocks[name] || [], block);
+    var blk = this.blocks[name][idx + 1];
+    var context = this;
+
+    if (idx === -1 || !blk) {
+      throw new Error('no super block available for "' + name + '"');
+    }
+
+    blk(env, context, frame, runtime, cb);
+  };
+
+  _proto2.addExport = function addExport(name) {
+    this.exported.push(name);
+  };
+
+  _proto2.getExported = function getExported() {
+    var _this5 = this;
+
+    var exported = {};
+    this.exported.forEach(function (name) {
+      exported[name] = _this5.ctx[name];
+    });
+    return exported;
+  };
+
+  return Context;
+}(Obj);
+
+var Template = /*#__PURE__*/function (_Obj2) {
+  _inheritsLoose(Template, _Obj2);
+
+  function Template() {
+    return _Obj2.apply(this, arguments) || this;
+  }
+
+  var _proto3 = Template.prototype;
+
+  _proto3.init = function init(src, env, path, eagerCompile) {
+    this.env = env || new Environment();
+
+    if (lib.isObject(src)) {
+      switch (src.type) {
+        case 'code':
+          this.tmplProps = src.obj;
+          break;
+
+        case 'string':
+          this.tmplStr = src.obj;
+          break;
+
+        default:
+          throw new Error("Unexpected template object type " + src.type + "; expected 'code', or 'string'");
+      }
+    } else if (lib.isString(src)) {
+      this.tmplStr = src;
+    } else {
+      throw new Error('src must be a string or an object describing the source');
+    }
+
+    this.path = path;
+
+    if (eagerCompile) {
+      try {
+        this._compile();
+      } catch (err) {
+        throw lib._prettifyError(this.path, this.env.opts.dev, err);
+      }
+    } else {
+      this.compiled = false;
+    }
+  };
+
+  _proto3.render = function render(ctx, parentFrame, cb) {
+    var _this6 = this;
+
+    if (typeof ctx === 'function') {
+      cb = ctx;
+      ctx = {};
+    } else if (typeof parentFrame === 'function') {
+      cb = parentFrame;
+      parentFrame = null;
+    } // If there is a parent frame, we are being called from internal
+    // code of another template, and the internal system
+    // depends on the sync/async nature of the parent template
+    // to be inherited, so force an async callback
+
+
+    var forceAsync = !parentFrame; // Catch compile errors for async rendering
+
+    try {
+      this.compile();
+    } catch (e) {
+      var err = lib._prettifyError(this.path, this.env.opts.dev, e);
+
+      if (cb) {
+        return callbackAsap(cb, err);
+      } else {
+        throw err;
+      }
+    }
+
+    var context = new Context(ctx || {}, this.blocks, this.env);
+    var frame = parentFrame ? parentFrame.push(true) : new Frame();
+    frame.topLevel = true;
+    var syncResult = null;
+    var didError = false;
+    this.rootRenderFunc(this.env, context, frame, globalRuntime, function (err, res) {
+      // TODO: this is actually a bug in the compiled template (because waterfall
+      // tasks are both not passing errors up the chain of callbacks AND are not
+      // causing a return from the top-most render function). But fixing that
+      // will require a more substantial change to the compiler.
+      if (didError && cb && typeof res !== 'undefined') {
+        // prevent multiple calls to cb
+        return;
+      }
+
+      if (err) {
+        err = lib._prettifyError(_this6.path, _this6.env.opts.dev, err);
+        didError = true;
+      }
+
+      if (cb) {
+        if (forceAsync) {
+          callbackAsap(cb, err, res);
+        } else {
+          cb(err, res);
+        }
+      } else {
+        if (err) {
+          throw err;
+        }
+
+        syncResult = res;
+      }
+    });
+    return syncResult;
+  };
+
+  _proto3.getExported = function getExported(ctx, parentFrame, cb) {
+    // eslint-disable-line consistent-return
+    if (typeof ctx === 'function') {
+      cb = ctx;
+      ctx = {};
+    }
+
+    if (typeof parentFrame === 'function') {
+      cb = parentFrame;
+      parentFrame = null;
+    } // Catch compile errors for async rendering
+
+
+    try {
+      this.compile();
+    } catch (e) {
+      if (cb) {
+        return cb(e);
+      } else {
+        throw e;
+      }
+    }
+
+    var frame = parentFrame ? parentFrame.push() : new Frame();
+    frame.topLevel = true; // Run the rootRenderFunc to populate the context with exported vars
+
+    var context = new Context(ctx || {}, this.blocks, this.env);
+    this.rootRenderFunc(this.env, context, frame, globalRuntime, function (err) {
+      if (err) {
+        cb(err, null);
+      } else {
+        cb(null, context.getExported());
+      }
+    });
+  };
+
+  _proto3.compile = function compile() {
+    if (!this.compiled) {
+      this._compile();
+    }
+  };
+
+  _proto3._compile = function _compile() {
+    var props;
+
+    if (this.tmplProps) {
+      props = this.tmplProps;
+    } else {
+      var source = compiler.compile(this.tmplStr, this.env.asyncFilters, this.env.extensionsList, this.path, this.env.opts);
+      var func = new Function(source); // eslint-disable-line no-new-func
+
+      props = func();
+    }
+
+    this.blocks = this._getBlocks(props);
+    this.rootRenderFunc = props.root;
+    this.compiled = true;
+  };
+
+  _proto3._getBlocks = function _getBlocks(props) {
+    var blocks = {};
+    lib.keys(props).forEach(function (k) {
+      if (k.slice(0, 2) === 'b_') {
+        blocks[k.slice(2)] = props[k];
+      }
+    });
+    return blocks;
+  };
+
+  return Template;
+}(Obj);
+
+module.exports = {
+  Environment: Environment,
+  Template: Template
+};
+
+/***/ }),
+
+/***/ 6548:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+var path = __nccwpck_require__(1017);
+
+module.exports = function express(env, app) {
+  function NunjucksView(name, opts) {
+    this.name = name;
+    this.path = name;
+    this.defaultEngine = opts.defaultEngine;
+    this.ext = path.extname(name);
+
+    if (!this.ext && !this.defaultEngine) {
+      throw new Error('No default engine was specified and no extension was provided.');
+    }
+
+    if (!this.ext) {
+      this.name += this.ext = (this.defaultEngine[0] !== '.' ? '.' : '') + this.defaultEngine;
+    }
+  }
+
+  NunjucksView.prototype.render = function render(opts, cb) {
+    env.render(this.name, opts, cb);
+  };
+
+  app.set('view', NunjucksView);
+  app.set('nunjucksEnv', env);
+  return env;
+};
+
+/***/ }),
+
+/***/ 9223:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+var lib = __nccwpck_require__(4127);
+
+var r = __nccwpck_require__(1998);
+
+var _exports = module.exports = {};
+
+function normalize(value, defaultValue) {
+  if (value === null || value === undefined || value === false) {
+    return defaultValue;
+  }
+
+  return value;
+}
+
+_exports.abs = Math.abs;
+
+function isNaN(num) {
+  return num !== num; // eslint-disable-line no-self-compare
+}
+
+function batch(arr, linecount, fillWith) {
+  var i;
+  var res = [];
+  var tmp = [];
+
+  for (i = 0; i < arr.length; i++) {
+    if (i % linecount === 0 && tmp.length) {
+      res.push(tmp);
+      tmp = [];
+    }
+
+    tmp.push(arr[i]);
+  }
+
+  if (tmp.length) {
+    if (fillWith) {
+      for (i = tmp.length; i < linecount; i++) {
+        tmp.push(fillWith);
+      }
+    }
+
+    res.push(tmp);
+  }
+
+  return res;
+}
+
+_exports.batch = batch;
+
+function capitalize(str) {
+  str = normalize(str, '');
+  var ret = str.toLowerCase();
+  return r.copySafeness(str, ret.charAt(0).toUpperCase() + ret.slice(1));
+}
+
+_exports.capitalize = capitalize;
+
+function center(str, width) {
+  str = normalize(str, '');
+  width = width || 80;
+
+  if (str.length >= width) {
+    return str;
+  }
+
+  var spaces = width - str.length;
+  var pre = lib.repeat(' ', spaces / 2 - spaces % 2);
+  var post = lib.repeat(' ', spaces / 2);
+  return r.copySafeness(str, pre + str + post);
+}
+
+_exports.center = center;
+
+function default_(val, def, bool) {
+  if (bool) {
+    return val || def;
+  } else {
+    return val !== undefined ? val : def;
+  }
+} // TODO: it is confusing to export something called 'default'
+
+
+_exports['default'] = default_; // eslint-disable-line dot-notation
+
+function dictsort(val, caseSensitive, by) {
+  if (!lib.isObject(val)) {
+    throw new lib.TemplateError('dictsort filter: val must be an object');
+  }
+
+  var array = []; // deliberately include properties from the object's prototype
+
+  for (var k in val) {
+    // eslint-disable-line guard-for-in, no-restricted-syntax
+    array.push([k, val[k]]);
+  }
+
+  var si;
+
+  if (by === undefined || by === 'key') {
+    si = 0;
+  } else if (by === 'value') {
+    si = 1;
+  } else {
+    throw new lib.TemplateError('dictsort filter: You can only sort by either key or value');
+  }
+
+  array.sort(function (t1, t2) {
+    var a = t1[si];
+    var b = t2[si];
+
+    if (!caseSensitive) {
+      if (lib.isString(a)) {
+        a = a.toUpperCase();
+      }
+
+      if (lib.isString(b)) {
+        b = b.toUpperCase();
+      }
+    }
+
+    return a > b ? 1 : a === b ? 0 : -1; // eslint-disable-line no-nested-ternary
+  });
+  return array;
+}
+
+_exports.dictsort = dictsort;
+
+function dump(obj, spaces) {
+  return JSON.stringify(obj, null, spaces);
+}
+
+_exports.dump = dump;
+
+function escape(str) {
+  if (str instanceof r.SafeString) {
+    return str;
+  }
+
+  str = str === null || str === undefined ? '' : str;
+  return r.markSafe(lib.escape(str.toString()));
+}
+
+_exports.escape = escape;
+
+function safe(str) {
+  if (str instanceof r.SafeString) {
+    return str;
+  }
+
+  str = str === null || str === undefined ? '' : str;
+  return r.markSafe(str.toString());
+}
+
+_exports.safe = safe;
+
+function first(arr) {
+  return arr[0];
+}
+
+_exports.first = first;
+
+function forceescape(str) {
+  str = str === null || str === undefined ? '' : str;
+  return r.markSafe(lib.escape(str.toString()));
+}
+
+_exports.forceescape = forceescape;
+
+function groupby(arr, attr) {
+  return lib.groupBy(arr, attr, this.env.opts.throwOnUndefined);
+}
+
+_exports.groupby = groupby;
+
+function indent(str, width, indentfirst) {
+  str = normalize(str, '');
+
+  if (str === '') {
+    return '';
+  }
+
+  width = width || 4; // let res = '';
+
+  var lines = str.split('\n');
+  var sp = lib.repeat(' ', width);
+  var res = lines.map(function (l, i) {
+    return i === 0 && !indentfirst ? l : "" + sp + l;
+  }).join('\n');
+  return r.copySafeness(str, res);
+}
+
+_exports.indent = indent;
+
+function join(arr, del, attr) {
+  del = del || '';
+
+  if (attr) {
+    arr = lib.map(arr, function (v) {
+      return v[attr];
+    });
+  }
+
+  return arr.join(del);
+}
+
+_exports.join = join;
+
+function last(arr) {
+  return arr[arr.length - 1];
+}
+
+_exports.last = last;
+
+function lengthFilter(val) {
+  var value = normalize(val, '');
+
+  if (value !== undefined) {
+    if (typeof Map === 'function' && value instanceof Map || typeof Set === 'function' && value instanceof Set) {
+      // ECMAScript 2015 Maps and Sets
+      return value.size;
+    }
+
+    if (lib.isObject(value) && !(value instanceof r.SafeString)) {
+      // Objects (besides SafeStrings), non-primative Arrays
+      return lib.keys(value).length;
+    }
+
+    return value.length;
+  }
+
+  return 0;
+}
+
+_exports.length = lengthFilter;
+
+function list(val) {
+  if (lib.isString(val)) {
+    return val.split('');
+  } else if (lib.isObject(val)) {
+    return lib._entries(val || {}).map(function (_ref) {
+      var key = _ref[0],
+          value = _ref[1];
+      return {
+        key: key,
+        value: value
+      };
+    });
+  } else if (lib.isArray(val)) {
+    return val;
+  } else {
+    throw new lib.TemplateError('list filter: type not iterable');
+  }
+}
+
+_exports.list = list;
+
+function lower(str) {
+  str = normalize(str, '');
+  return str.toLowerCase();
+}
+
+_exports.lower = lower;
+
+function nl2br(str) {
+  if (str === null || str === undefined) {
+    return '';
+  }
+
+  return r.copySafeness(str, str.replace(/\r\n|\n/g, '<br />\n'));
+}
+
+_exports.nl2br = nl2br;
+
+function random(arr) {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+_exports.random = random;
+/**
+ * Construct select or reject filter
+ *
+ * @param {boolean} expectedTestResult
+ * @returns {function(array, string, *): array}
+ */
+
+function getSelectOrReject(expectedTestResult) {
+  function filter(arr, testName, secondArg) {
+    if (testName === void 0) {
+      testName = 'truthy';
+    }
+
+    var context = this;
+    var test = context.env.getTest(testName);
+    return lib.toArray(arr).filter(function examineTestResult(item) {
+      return test.call(context, item, secondArg) === expectedTestResult;
+    });
+  }
+
+  return filter;
+}
+
+_exports.reject = getSelectOrReject(false);
+
+function rejectattr(arr, attr) {
+  return arr.filter(function (item) {
+    return !item[attr];
+  });
+}
+
+_exports.rejectattr = rejectattr;
+_exports.select = getSelectOrReject(true);
+
+function selectattr(arr, attr) {
+  return arr.filter(function (item) {
+    return !!item[attr];
+  });
+}
+
+_exports.selectattr = selectattr;
+
+function replace(str, old, new_, maxCount) {
+  var originalStr = str;
+
+  if (old instanceof RegExp) {
+    return str.replace(old, new_);
+  }
+
+  if (typeof maxCount === 'undefined') {
+    maxCount = -1;
+  }
+
+  var res = ''; // Output
+  // Cast Numbers in the search term to string
+
+  if (typeof old === 'number') {
+    old = '' + old;
+  } else if (typeof old !== 'string') {
+    // If it is something other than number or string,
+    // return the original string
+    return str;
+  } // Cast numbers in the replacement to string
+
+
+  if (typeof str === 'number') {
+    str = '' + str;
+  } // If by now, we don't have a string, throw it back
+
+
+  if (typeof str !== 'string' && !(str instanceof r.SafeString)) {
+    return str;
+  } // ShortCircuits
+
+
+  if (old === '') {
+    // Mimic the python behaviour: empty string is replaced
+    // by replacement e.g. "abc"|replace("", ".") -> .a.b.c.
+    res = new_ + str.split('').join(new_) + new_;
+    return r.copySafeness(str, res);
+  }
+
+  var nextIndex = str.indexOf(old); // if # of replacements to perform is 0, or the string to does
+  // not contain the old value, return the string
+
+  if (maxCount === 0 || nextIndex === -1) {
+    return str;
+  }
+
+  var pos = 0;
+  var count = 0; // # of replacements made
+
+  while (nextIndex > -1 && (maxCount === -1 || count < maxCount)) {
+    // Grab the next chunk of src string and add it with the
+    // replacement, to the result
+    res += str.substring(pos, nextIndex) + new_; // Increment our pointer in the src string
+
+    pos = nextIndex + old.length;
+    count++; // See if there are any more replacements to be made
+
+    nextIndex = str.indexOf(old, pos);
+  } // We've either reached the end, or done the max # of
+  // replacements, tack on any remaining string
+
+
+  if (pos < str.length) {
+    res += str.substring(pos);
+  }
+
+  return r.copySafeness(originalStr, res);
+}
+
+_exports.replace = replace;
+
+function reverse(val) {
+  var arr;
+
+  if (lib.isString(val)) {
+    arr = list(val);
+  } else {
+    // Copy it
+    arr = lib.map(val, function (v) {
+      return v;
+    });
+  }
+
+  arr.reverse();
+
+  if (lib.isString(val)) {
+    return r.copySafeness(val, arr.join(''));
+  }
+
+  return arr;
+}
+
+_exports.reverse = reverse;
+
+function round(val, precision, method) {
+  precision = precision || 0;
+  var factor = Math.pow(10, precision);
+  var rounder;
+
+  if (method === 'ceil') {
+    rounder = Math.ceil;
+  } else if (method === 'floor') {
+    rounder = Math.floor;
+  } else {
+    rounder = Math.round;
+  }
+
+  return rounder(val * factor) / factor;
+}
+
+_exports.round = round;
+
+function slice(arr, slices, fillWith) {
+  var sliceLength = Math.floor(arr.length / slices);
+  var extra = arr.length % slices;
+  var res = [];
+  var offset = 0;
+
+  for (var i = 0; i < slices; i++) {
+    var start = offset + i * sliceLength;
+
+    if (i < extra) {
+      offset++;
+    }
+
+    var end = offset + (i + 1) * sliceLength;
+    var currSlice = arr.slice(start, end);
+
+    if (fillWith && i >= extra) {
+      currSlice.push(fillWith);
+    }
+
+    res.push(currSlice);
+  }
+
+  return res;
+}
+
+_exports.slice = slice;
+
+function sum(arr, attr, start) {
+  if (start === void 0) {
+    start = 0;
+  }
+
+  if (attr) {
+    arr = lib.map(arr, function (v) {
+      return v[attr];
+    });
+  }
+
+  return start + arr.reduce(function (a, b) {
+    return a + b;
+  }, 0);
+}
+
+_exports.sum = sum;
+_exports.sort = r.makeMacro(['value', 'reverse', 'case_sensitive', 'attribute'], [], function sortFilter(arr, reversed, caseSens, attr) {
+  var _this = this;
+
+  // Copy it
+  var array = lib.map(arr, function (v) {
+    return v;
+  });
+  var getAttribute = lib.getAttrGetter(attr);
+  array.sort(function (a, b) {
+    var x = attr ? getAttribute(a) : a;
+    var y = attr ? getAttribute(b) : b;
+
+    if (_this.env.opts.throwOnUndefined && attr && (x === undefined || y === undefined)) {
+      throw new TypeError("sort: attribute \"" + attr + "\" resolved to undefined");
+    }
+
+    if (!caseSens && lib.isString(x) && lib.isString(y)) {
+      x = x.toLowerCase();
+      y = y.toLowerCase();
+    }
+
+    if (x < y) {
+      return reversed ? 1 : -1;
+    } else if (x > y) {
+      return reversed ? -1 : 1;
+    } else {
+      return 0;
+    }
+  });
+  return array;
+});
+
+function string(obj) {
+  return r.copySafeness(obj, obj);
+}
+
+_exports.string = string;
+
+function striptags(input, preserveLinebreaks) {
+  input = normalize(input, '');
+  var tags = /<\/?([a-z][a-z0-9]*)\b[^>]*>|<!--[\s\S]*?-->/gi;
+  var trimmedInput = trim(input.replace(tags, ''));
+  var res = '';
+
+  if (preserveLinebreaks) {
+    res = trimmedInput.replace(/^ +| +$/gm, '') // remove leading and trailing spaces
+    .replace(/ +/g, ' ') // squash adjacent spaces
+    .replace(/(\r\n)/g, '\n') // normalize linebreaks (CRLF -> LF)
+    .replace(/\n\n\n+/g, '\n\n'); // squash abnormal adjacent linebreaks
+  } else {
+    res = trimmedInput.replace(/\s+/gi, ' ');
+  }
+
+  return r.copySafeness(input, res);
+}
+
+_exports.striptags = striptags;
+
+function title(str) {
+  str = normalize(str, '');
+  var words = str.split(' ').map(function (word) {
+    return capitalize(word);
+  });
+  return r.copySafeness(str, words.join(' '));
+}
+
+_exports.title = title;
+
+function trim(str) {
+  return r.copySafeness(str, str.replace(/^\s*|\s*$/g, ''));
+}
+
+_exports.trim = trim;
+
+function truncate(input, length, killwords, end) {
+  var orig = input;
+  input = normalize(input, '');
+  length = length || 255;
+
+  if (input.length <= length) {
+    return input;
+  }
+
+  if (killwords) {
+    input = input.substring(0, length);
+  } else {
+    var idx = input.lastIndexOf(' ', length);
+
+    if (idx === -1) {
+      idx = length;
+    }
+
+    input = input.substring(0, idx);
+  }
+
+  input += end !== undefined && end !== null ? end : '...';
+  return r.copySafeness(orig, input);
+}
+
+_exports.truncate = truncate;
+
+function upper(str) {
+  str = normalize(str, '');
+  return str.toUpperCase();
+}
+
+_exports.upper = upper;
+
+function urlencode(obj) {
+  var enc = encodeURIComponent;
+
+  if (lib.isString(obj)) {
+    return enc(obj);
+  } else {
+    var keyvals = lib.isArray(obj) ? obj : lib._entries(obj);
+    return keyvals.map(function (_ref2) {
+      var k = _ref2[0],
+          v = _ref2[1];
+      return enc(k) + "=" + enc(v);
+    }).join('&');
+  }
+}
+
+_exports.urlencode = urlencode; // For the jinja regexp, see
+// https://github.com/mitsuhiko/jinja2/blob/f15b814dcba6aa12bc74d1f7d0c881d55f7126be/jinja2/utils.py#L20-L23
+
+var puncRe = /^(?:\(|<|&lt;)?(.*?)(?:\.|,|\)|\n|&gt;)?$/; // from http://blog.gerv.net/2011/05/html5_email_address_regexp/
+
+var emailRe = /^[\w.!#$%&'*+\-\/=?\^`{|}~]+@[a-z\d\-]+(\.[a-z\d\-]+)+$/i;
+var httpHttpsRe = /^https?:\/\/.*$/;
+var wwwRe = /^www\./;
+var tldRe = /\.(?:org|net|com)(?:\:|\/|$)/;
+
+function urlize(str, length, nofollow) {
+  if (isNaN(length)) {
+    length = Infinity;
+  }
+
+  var noFollowAttr = nofollow === true ? ' rel="nofollow"' : '';
+  var words = str.split(/(\s+)/).filter(function (word) {
+    // If the word has no length, bail. This can happen for str with
+    // trailing whitespace.
+    return word && word.length;
+  }).map(function (word) {
+    var matches = word.match(puncRe);
+    var possibleUrl = matches ? matches[1] : word;
+    var shortUrl = possibleUrl.substr(0, length); // url that starts with http or https
+
+    if (httpHttpsRe.test(possibleUrl)) {
+      return "<a href=\"" + possibleUrl + "\"" + noFollowAttr + ">" + shortUrl + "</a>";
+    } // url that starts with www.
+
+
+    if (wwwRe.test(possibleUrl)) {
+      return "<a href=\"http://" + possibleUrl + "\"" + noFollowAttr + ">" + shortUrl + "</a>";
+    } // an email address of the form username@domain.tld
+
+
+    if (emailRe.test(possibleUrl)) {
+      return "<a href=\"mailto:" + possibleUrl + "\">" + possibleUrl + "</a>";
+    } // url that ends in .com, .org or .net that is not an email address
+
+
+    if (tldRe.test(possibleUrl)) {
+      return "<a href=\"http://" + possibleUrl + "\"" + noFollowAttr + ">" + shortUrl + "</a>";
+    }
+
+    return word;
+  });
+  return words.join('');
+}
+
+_exports.urlize = urlize;
+
+function wordcount(str) {
+  str = normalize(str, '');
+  var words = str ? str.match(/\w+/g) : null;
+  return words ? words.length : null;
+}
+
+_exports.wordcount = wordcount;
+
+function float(val, def) {
+  var res = parseFloat(val);
+  return isNaN(res) ? def : res;
+}
+
+_exports.float = float;
+var intFilter = r.makeMacro(['value', 'default', 'base'], [], function doInt(value, defaultValue, base) {
+  if (base === void 0) {
+    base = 10;
+  }
+
+  var res = parseInt(value, base);
+  return isNaN(res) ? defaultValue : res;
+});
+_exports.int = intFilter; // Aliases
+
+_exports.d = _exports.default;
+_exports.e = _exports.escape;
+
+/***/ }),
+
+/***/ 8956:
+/***/ ((module) => {
+
+"use strict";
+
+
+function _cycler(items) {
+  var index = -1;
+  return {
+    current: null,
+    reset: function reset() {
+      index = -1;
+      this.current = null;
+    },
+    next: function next() {
+      index++;
+
+      if (index >= items.length) {
+        index = 0;
+      }
+
+      this.current = items[index];
+      return this.current;
+    }
+  };
+}
+
+function _joiner(sep) {
+  sep = sep || ',';
+  var first = true;
+  return function () {
+    var val = first ? '' : sep;
+    first = false;
+    return val;
+  };
+} // Making this a function instead so it returns a new object
+// each time it's called. That way, if something like an environment
+// uses it, they will each have their own copy.
+
+
+function globals() {
+  return {
+    range: function range(start, stop, step) {
+      if (typeof stop === 'undefined') {
+        stop = start;
+        start = 0;
+        step = 1;
+      } else if (!step) {
+        step = 1;
+      }
+
+      var arr = [];
+
+      if (step > 0) {
+        for (var i = start; i < stop; i += step) {
+          arr.push(i);
+        }
+      } else {
+        for (var _i = start; _i > stop; _i += step) {
+          // eslint-disable-line for-direction
+          arr.push(_i);
+        }
+      }
+
+      return arr;
+    },
+    cycler: function cycler() {
+      return _cycler(Array.prototype.slice.call(arguments));
+    },
+    joiner: function joiner(sep) {
+      return _joiner(sep);
+    }
+  };
+}
+
+module.exports = globals;
+
+/***/ }),
+
+/***/ 6976:
+/***/ ((module) => {
+
+"use strict";
+
+
+function installCompat() {
+  'use strict';
+  /* eslint-disable camelcase */
+  // This must be called like `nunjucks.installCompat` so that `this`
+  // references the nunjucks instance
+
+  var runtime = this.runtime;
+  var lib = this.lib; // Handle slim case where these 'modules' are excluded from the built source
+
+  var Compiler = this.compiler.Compiler;
+  var Parser = this.parser.Parser;
+  var nodes = this.nodes;
+  var lexer = this.lexer;
+  var orig_contextOrFrameLookup = runtime.contextOrFrameLookup;
+  var orig_memberLookup = runtime.memberLookup;
+  var orig_Compiler_assertType;
+  var orig_Parser_parseAggregate;
+
+  if (Compiler) {
+    orig_Compiler_assertType = Compiler.prototype.assertType;
+  }
+
+  if (Parser) {
+    orig_Parser_parseAggregate = Parser.prototype.parseAggregate;
+  }
+
+  function uninstall() {
+    runtime.contextOrFrameLookup = orig_contextOrFrameLookup;
+    runtime.memberLookup = orig_memberLookup;
+
+    if (Compiler) {
+      Compiler.prototype.assertType = orig_Compiler_assertType;
+    }
+
+    if (Parser) {
+      Parser.prototype.parseAggregate = orig_Parser_parseAggregate;
+    }
+  }
+
+  runtime.contextOrFrameLookup = function contextOrFrameLookup(context, frame, key) {
+    var val = orig_contextOrFrameLookup.apply(this, arguments);
+
+    if (val !== undefined) {
+      return val;
+    }
+
+    switch (key) {
+      case 'True':
+        return true;
+
+      case 'False':
+        return false;
+
+      case 'None':
+        return null;
+
+      default:
+        return undefined;
+    }
+  };
+
+  function getTokensState(tokens) {
+    return {
+      index: tokens.index,
+      lineno: tokens.lineno,
+      colno: tokens.colno
+    };
+  }
+
+  if (process.env.BUILD_TYPE !== 'SLIM' && nodes && Compiler && Parser) {
+    // i.e., not slim mode
+    var Slice = nodes.Node.extend('Slice', {
+      fields: ['start', 'stop', 'step'],
+      init: function init(lineno, colno, start, stop, step) {
+        start = start || new nodes.Literal(lineno, colno, null);
+        stop = stop || new nodes.Literal(lineno, colno, null);
+        step = step || new nodes.Literal(lineno, colno, 1);
+        this.parent(lineno, colno, start, stop, step);
+      }
+    });
+
+    Compiler.prototype.assertType = function assertType(node) {
+      if (node instanceof Slice) {
+        return;
+      }
+
+      orig_Compiler_assertType.apply(this, arguments);
+    };
+
+    Compiler.prototype.compileSlice = function compileSlice(node, frame) {
+      this._emit('(');
+
+      this._compileExpression(node.start, frame);
+
+      this._emit('),(');
+
+      this._compileExpression(node.stop, frame);
+
+      this._emit('),(');
+
+      this._compileExpression(node.step, frame);
+
+      this._emit(')');
+    };
+
+    Parser.prototype.parseAggregate = function parseAggregate() {
+      var _this = this;
+
+      var origState = getTokensState(this.tokens); // Set back one accounting for opening bracket/parens
+
+      origState.colno--;
+      origState.index--;
+
+      try {
+        return orig_Parser_parseAggregate.apply(this);
+      } catch (e) {
+        var errState = getTokensState(this.tokens);
+
+        var rethrow = function rethrow() {
+          lib._assign(_this.tokens, errState);
+
+          return e;
+        }; // Reset to state before original parseAggregate called
+
+
+        lib._assign(this.tokens, origState);
+
+        this.peeked = false;
+        var tok = this.peekToken();
+
+        if (tok.type !== lexer.TOKEN_LEFT_BRACKET) {
+          throw rethrow();
+        } else {
+          this.nextToken();
+        }
+
+        var node = new Slice(tok.lineno, tok.colno); // If we don't encounter a colon while parsing, this is not a slice,
+        // so re-raise the original exception.
+
+        var isSlice = false;
+
+        for (var i = 0; i <= node.fields.length; i++) {
+          if (this.skip(lexer.TOKEN_RIGHT_BRACKET)) {
+            break;
+          }
+
+          if (i === node.fields.length) {
+            if (isSlice) {
+              this.fail('parseSlice: too many slice components', tok.lineno, tok.colno);
+            } else {
+              break;
+            }
+          }
+
+          if (this.skip(lexer.TOKEN_COLON)) {
+            isSlice = true;
+          } else {
+            var field = node.fields[i];
+            node[field] = this.parseExpression();
+            isSlice = this.skip(lexer.TOKEN_COLON) || isSlice;
+          }
+        }
+
+        if (!isSlice) {
+          throw rethrow();
+        }
+
+        return new nodes.Array(tok.lineno, tok.colno, [node]);
+      }
+    };
+  }
+
+  function sliceLookup(obj, start, stop, step) {
+    obj = obj || [];
+
+    if (start === null) {
+      start = step < 0 ? obj.length - 1 : 0;
+    }
+
+    if (stop === null) {
+      stop = step < 0 ? -1 : obj.length;
+    } else if (stop < 0) {
+      stop += obj.length;
+    }
+
+    if (start < 0) {
+      start += obj.length;
+    }
+
+    var results = [];
+
+    for (var i = start;; i += step) {
+      if (i < 0 || i > obj.length) {
+        break;
+      }
+
+      if (step > 0 && i >= stop) {
+        break;
+      }
+
+      if (step < 0 && i <= stop) {
+        break;
+      }
+
+      results.push(runtime.memberLookup(obj, i));
+    }
+
+    return results;
+  }
+
+  function hasOwnProp(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+  }
+
+  var ARRAY_MEMBERS = {
+    pop: function pop(index) {
+      if (index === undefined) {
+        return this.pop();
+      }
+
+      if (index >= this.length || index < 0) {
+        throw new Error('KeyError');
+      }
+
+      return this.splice(index, 1);
+    },
+    append: function append(element) {
+      return this.push(element);
+    },
+    remove: function remove(element) {
+      for (var i = 0; i < this.length; i++) {
+        if (this[i] === element) {
+          return this.splice(i, 1);
+        }
+      }
+
+      throw new Error('ValueError');
+    },
+    count: function count(element) {
+      var count = 0;
+
+      for (var i = 0; i < this.length; i++) {
+        if (this[i] === element) {
+          count++;
+        }
+      }
+
+      return count;
+    },
+    index: function index(element) {
+      var i;
+
+      if ((i = this.indexOf(element)) === -1) {
+        throw new Error('ValueError');
+      }
+
+      return i;
+    },
+    find: function find(element) {
+      return this.indexOf(element);
+    },
+    insert: function insert(index, elem) {
+      return this.splice(index, 0, elem);
+    }
+  };
+  var OBJECT_MEMBERS = {
+    items: function items() {
+      return lib._entries(this);
+    },
+    values: function values() {
+      return lib._values(this);
+    },
+    keys: function keys() {
+      return lib.keys(this);
+    },
+    get: function get(key, def) {
+      var output = this[key];
+
+      if (output === undefined) {
+        output = def;
+      }
+
+      return output;
+    },
+    has_key: function has_key(key) {
+      return hasOwnProp(this, key);
+    },
+    pop: function pop(key, def) {
+      var output = this[key];
+
+      if (output === undefined && def !== undefined) {
+        output = def;
+      } else if (output === undefined) {
+        throw new Error('KeyError');
+      } else {
+        delete this[key];
+      }
+
+      return output;
+    },
+    popitem: function popitem() {
+      var keys = lib.keys(this);
+
+      if (!keys.length) {
+        throw new Error('KeyError');
+      }
+
+      var k = keys[0];
+      var val = this[k];
+      delete this[k];
+      return [k, val];
+    },
+    setdefault: function setdefault(key, def) {
+      if (def === void 0) {
+        def = null;
+      }
+
+      if (!(key in this)) {
+        this[key] = def;
+      }
+
+      return this[key];
+    },
+    update: function update(kwargs) {
+      lib._assign(this, kwargs);
+
+      return null; // Always returns None
+    }
+  };
+  OBJECT_MEMBERS.iteritems = OBJECT_MEMBERS.items;
+  OBJECT_MEMBERS.itervalues = OBJECT_MEMBERS.values;
+  OBJECT_MEMBERS.iterkeys = OBJECT_MEMBERS.keys;
+
+  runtime.memberLookup = function memberLookup(obj, val, autoescape) {
+    if (arguments.length === 4) {
+      return sliceLookup.apply(this, arguments);
+    }
+
+    obj = obj || {}; // If the object is an object, return any of the methods that Python would
+    // otherwise provide.
+
+    if (lib.isArray(obj) && hasOwnProp(ARRAY_MEMBERS, val)) {
+      return ARRAY_MEMBERS[val].bind(obj);
+    }
+
+    if (lib.isObject(obj) && hasOwnProp(OBJECT_MEMBERS, val)) {
+      return OBJECT_MEMBERS[val].bind(obj);
+    }
+
+    return orig_memberLookup.apply(this, arguments);
+  };
+
+  return uninstall;
+}
+
+module.exports = installCompat;
+
+/***/ }),
+
+/***/ 3158:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+var lib = __nccwpck_require__(4127);
+
+var whitespaceChars = " \n\t\r\xA0";
+var delimChars = '()[]{}%*-+~/#,:|.<>=!';
+var intChars = '0123456789';
+var BLOCK_START = '{%';
+var BLOCK_END = '%}';
+var VARIABLE_START = '{{';
+var VARIABLE_END = '}}';
+var COMMENT_START = '{#';
+var COMMENT_END = '#}';
+var TOKEN_STRING = 'string';
+var TOKEN_WHITESPACE = 'whitespace';
+var TOKEN_DATA = 'data';
+var TOKEN_BLOCK_START = 'block-start';
+var TOKEN_BLOCK_END = 'block-end';
+var TOKEN_VARIABLE_START = 'variable-start';
+var TOKEN_VARIABLE_END = 'variable-end';
+var TOKEN_COMMENT = 'comment';
+var TOKEN_LEFT_PAREN = 'left-paren';
+var TOKEN_RIGHT_PAREN = 'right-paren';
+var TOKEN_LEFT_BRACKET = 'left-bracket';
+var TOKEN_RIGHT_BRACKET = 'right-bracket';
+var TOKEN_LEFT_CURLY = 'left-curly';
+var TOKEN_RIGHT_CURLY = 'right-curly';
+var TOKEN_OPERATOR = 'operator';
+var TOKEN_COMMA = 'comma';
+var TOKEN_COLON = 'colon';
+var TOKEN_TILDE = 'tilde';
+var TOKEN_PIPE = 'pipe';
+var TOKEN_INT = 'int';
+var TOKEN_FLOAT = 'float';
+var TOKEN_BOOLEAN = 'boolean';
+var TOKEN_NONE = 'none';
+var TOKEN_SYMBOL = 'symbol';
+var TOKEN_SPECIAL = 'special';
+var TOKEN_REGEX = 'regex';
+
+function token(type, value, lineno, colno) {
+  return {
+    type: type,
+    value: value,
+    lineno: lineno,
+    colno: colno
+  };
+}
+
+var Tokenizer = /*#__PURE__*/function () {
+  function Tokenizer(str, opts) {
+    this.str = str;
+    this.index = 0;
+    this.len = str.length;
+    this.lineno = 0;
+    this.colno = 0;
+    this.in_code = false;
+    opts = opts || {};
+    var tags = opts.tags || {};
+    this.tags = {
+      BLOCK_START: tags.blockStart || BLOCK_START,
+      BLOCK_END: tags.blockEnd || BLOCK_END,
+      VARIABLE_START: tags.variableStart || VARIABLE_START,
+      VARIABLE_END: tags.variableEnd || VARIABLE_END,
+      COMMENT_START: tags.commentStart || COMMENT_START,
+      COMMENT_END: tags.commentEnd || COMMENT_END
+    };
+    this.trimBlocks = !!opts.trimBlocks;
+    this.lstripBlocks = !!opts.lstripBlocks;
+  }
+
+  var _proto = Tokenizer.prototype;
+
+  _proto.nextToken = function nextToken() {
+    var lineno = this.lineno;
+    var colno = this.colno;
+    var tok;
+
+    if (this.in_code) {
+      // Otherwise, if we are in a block parse it as code
+      var cur = this.current();
+
+      if (this.isFinished()) {
+        // We have nothing else to parse
+        return null;
+      } else if (cur === '"' || cur === '\'') {
+        // We've hit a string
+        return token(TOKEN_STRING, this._parseString(cur), lineno, colno);
+      } else if (tok = this._extract(whitespaceChars)) {
+        // We hit some whitespace
+        return token(TOKEN_WHITESPACE, tok, lineno, colno);
+      } else if ((tok = this._extractString(this.tags.BLOCK_END)) || (tok = this._extractString('-' + this.tags.BLOCK_END))) {
+        // Special check for the block end tag
+        //
+        // It is a requirement that start and end tags are composed of
+        // delimiter characters (%{}[] etc), and our code always
+        // breaks on delimiters so we can assume the token parsing
+        // doesn't consume these elsewhere
+        this.in_code = false;
+
+        if (this.trimBlocks) {
+          cur = this.current();
+
+          if (cur === '\n') {
+            // Skip newline
+            this.forward();
+          } else if (cur === '\r') {
+            // Skip CRLF newline
+            this.forward();
+            cur = this.current();
+
+            if (cur === '\n') {
+              this.forward();
+            } else {
+              // Was not a CRLF, so go back
+              this.back();
+            }
+          }
+        }
+
+        return token(TOKEN_BLOCK_END, tok, lineno, colno);
+      } else if ((tok = this._extractString(this.tags.VARIABLE_END)) || (tok = this._extractString('-' + this.tags.VARIABLE_END))) {
+        // Special check for variable end tag (see above)
+        this.in_code = false;
+        return token(TOKEN_VARIABLE_END, tok, lineno, colno);
+      } else if (cur === 'r' && this.str.charAt(this.index + 1) === '/') {
+        // Skip past 'r/'.
+        this.forwardN(2); // Extract until the end of the regex -- / ends it, \/ does not.
+
+        var regexBody = '';
+
+        while (!this.isFinished()) {
+          if (this.current() === '/' && this.previous() !== '\\') {
+            this.forward();
+            break;
+          } else {
+            regexBody += this.current();
+            this.forward();
+          }
+        } // Check for flags.
+        // The possible flags are according to https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/RegExp)
+
+
+        var POSSIBLE_FLAGS = ['g', 'i', 'm', 'y'];
+        var regexFlags = '';
+
+        while (!this.isFinished()) {
+          var isCurrentAFlag = POSSIBLE_FLAGS.indexOf(this.current()) !== -1;
+
+          if (isCurrentAFlag) {
+            regexFlags += this.current();
+            this.forward();
+          } else {
+            break;
+          }
+        }
+
+        return token(TOKEN_REGEX, {
+          body: regexBody,
+          flags: regexFlags
+        }, lineno, colno);
+      } else if (delimChars.indexOf(cur) !== -1) {
+        // We've hit a delimiter (a special char like a bracket)
+        this.forward();
+        var complexOps = ['==', '===', '!=', '!==', '<=', '>=', '//', '**'];
+        var curComplex = cur + this.current();
+        var type;
+
+        if (lib.indexOf(complexOps, curComplex) !== -1) {
+          this.forward();
+          cur = curComplex; // See if this is a strict equality/inequality comparator
+
+          if (lib.indexOf(complexOps, curComplex + this.current()) !== -1) {
+            cur = curComplex + this.current();
+            this.forward();
+          }
+        }
+
+        switch (cur) {
+          case '(':
+            type = TOKEN_LEFT_PAREN;
+            break;
+
+          case ')':
+            type = TOKEN_RIGHT_PAREN;
+            break;
+
+          case '[':
+            type = TOKEN_LEFT_BRACKET;
+            break;
+
+          case ']':
+            type = TOKEN_RIGHT_BRACKET;
+            break;
+
+          case '{':
+            type = TOKEN_LEFT_CURLY;
+            break;
+
+          case '}':
+            type = TOKEN_RIGHT_CURLY;
+            break;
+
+          case ',':
+            type = TOKEN_COMMA;
+            break;
+
+          case ':':
+            type = TOKEN_COLON;
+            break;
+
+          case '~':
+            type = TOKEN_TILDE;
+            break;
+
+          case '|':
+            type = TOKEN_PIPE;
+            break;
+
+          default:
+            type = TOKEN_OPERATOR;
+        }
+
+        return token(type, cur, lineno, colno);
+      } else {
+        // We are not at whitespace or a delimiter, so extract the
+        // text and parse it
+        tok = this._extractUntil(whitespaceChars + delimChars);
+
+        if (tok.match(/^[-+]?[0-9]+$/)) {
+          if (this.current() === '.') {
+            this.forward();
+
+            var dec = this._extract(intChars);
+
+            return token(TOKEN_FLOAT, tok + '.' + dec, lineno, colno);
+          } else {
+            return token(TOKEN_INT, tok, lineno, colno);
+          }
+        } else if (tok.match(/^(true|false)$/)) {
+          return token(TOKEN_BOOLEAN, tok, lineno, colno);
+        } else if (tok === 'none') {
+          return token(TOKEN_NONE, tok, lineno, colno);
+          /*
+           * Added to make the test `null is null` evaluate truthily.
+           * Otherwise, Nunjucks will look up null in the context and
+           * return `undefined`, which is not what we want. This *may* have
+           * consequences is someone is using null in their templates as a
+           * variable.
+           */
+        } else if (tok === 'null') {
+          return token(TOKEN_NONE, tok, lineno, colno);
+        } else if (tok) {
+          return token(TOKEN_SYMBOL, tok, lineno, colno);
+        } else {
+          throw new Error('Unexpected value while parsing: ' + tok);
+        }
+      }
+    } else {
+      // Parse out the template text, breaking on tag
+      // delimiters because we need to look for block/variable start
+      // tags (don't use the full delimChars for optimization)
+      var beginChars = this.tags.BLOCK_START.charAt(0) + this.tags.VARIABLE_START.charAt(0) + this.tags.COMMENT_START.charAt(0) + this.tags.COMMENT_END.charAt(0);
+
+      if (this.isFinished()) {
+        return null;
+      } else if ((tok = this._extractString(this.tags.BLOCK_START + '-')) || (tok = this._extractString(this.tags.BLOCK_START))) {
+        this.in_code = true;
+        return token(TOKEN_BLOCK_START, tok, lineno, colno);
+      } else if ((tok = this._extractString(this.tags.VARIABLE_START + '-')) || (tok = this._extractString(this.tags.VARIABLE_START))) {
+        this.in_code = true;
+        return token(TOKEN_VARIABLE_START, tok, lineno, colno);
+      } else {
+        tok = '';
+        var data;
+        var inComment = false;
+
+        if (this._matches(this.tags.COMMENT_START)) {
+          inComment = true;
+          tok = this._extractString(this.tags.COMMENT_START);
+        } // Continually consume text, breaking on the tag delimiter
+        // characters and checking to see if it's a start tag.
+        //
+        // We could hit the end of the template in the middle of
+        // our looping, so check for the null return value from
+        // _extractUntil
+
+
+        while ((data = this._extractUntil(beginChars)) !== null) {
+          tok += data;
+
+          if ((this._matches(this.tags.BLOCK_START) || this._matches(this.tags.VARIABLE_START) || this._matches(this.tags.COMMENT_START)) && !inComment) {
+            if (this.lstripBlocks && this._matches(this.tags.BLOCK_START) && this.colno > 0 && this.colno <= tok.length) {
+              var lastLine = tok.slice(-this.colno);
+
+              if (/^\s+$/.test(lastLine)) {
+                // Remove block leading whitespace from beginning of the string
+                tok = tok.slice(0, -this.colno);
+
+                if (!tok.length) {
+                  // All data removed, collapse to avoid unnecessary nodes
+                  // by returning next token (block start)
+                  return this.nextToken();
+                }
+              }
+            } // If it is a start tag, stop looping
+
+
+            break;
+          } else if (this._matches(this.tags.COMMENT_END)) {
+            if (!inComment) {
+              throw new Error('unexpected end of comment');
+            }
+
+            tok += this._extractString(this.tags.COMMENT_END);
+            break;
+          } else {
+            // It does not match any tag, so add the character and
+            // carry on
+            tok += this.current();
+            this.forward();
+          }
+        }
+
+        if (data === null && inComment) {
+          throw new Error('expected end of comment, got end of file');
+        }
+
+        return token(inComment ? TOKEN_COMMENT : TOKEN_DATA, tok, lineno, colno);
+      }
+    }
+  };
+
+  _proto._parseString = function _parseString(delimiter) {
+    this.forward();
+    var str = '';
+
+    while (!this.isFinished() && this.current() !== delimiter) {
+      var cur = this.current();
+
+      if (cur === '\\') {
+        this.forward();
+
+        switch (this.current()) {
+          case 'n':
+            str += '\n';
+            break;
+
+          case 't':
+            str += '\t';
+            break;
+
+          case 'r':
+            str += '\r';
+            break;
+
+          default:
+            str += this.current();
+        }
+
+        this.forward();
+      } else {
+        str += cur;
+        this.forward();
+      }
+    }
+
+    this.forward();
+    return str;
+  };
+
+  _proto._matches = function _matches(str) {
+    if (this.index + str.length > this.len) {
+      return null;
+    }
+
+    var m = this.str.slice(this.index, this.index + str.length);
+    return m === str;
+  };
+
+  _proto._extractString = function _extractString(str) {
+    if (this._matches(str)) {
+      this.forwardN(str.length);
+      return str;
+    }
+
+    return null;
+  };
+
+  _proto._extractUntil = function _extractUntil(charString) {
+    // Extract all non-matching chars, with the default matching set
+    // to everything
+    return this._extractMatching(true, charString || '');
+  };
+
+  _proto._extract = function _extract(charString) {
+    // Extract all matching chars (no default, so charString must be
+    // explicit)
+    return this._extractMatching(false, charString);
+  };
+
+  _proto._extractMatching = function _extractMatching(breakOnMatch, charString) {
+    // Pull out characters until a breaking char is hit.
+    // If breakOnMatch is false, a non-matching char stops it.
+    // If breakOnMatch is true, a matching char stops it.
+    if (this.isFinished()) {
+      return null;
+    }
+
+    var first = charString.indexOf(this.current()); // Only proceed if the first character doesn't meet our condition
+
+    if (breakOnMatch && first === -1 || !breakOnMatch && first !== -1) {
+      var t = this.current();
+      this.forward(); // And pull out all the chars one at a time until we hit a
+      // breaking char
+
+      var idx = charString.indexOf(this.current());
+
+      while ((breakOnMatch && idx === -1 || !breakOnMatch && idx !== -1) && !this.isFinished()) {
+        t += this.current();
+        this.forward();
+        idx = charString.indexOf(this.current());
+      }
+
+      return t;
+    }
+
+    return '';
+  };
+
+  _proto._extractRegex = function _extractRegex(regex) {
+    var matches = this.currentStr().match(regex);
+
+    if (!matches) {
+      return null;
+    } // Move forward whatever was matched
+
+
+    this.forwardN(matches[0].length);
+    return matches;
+  };
+
+  _proto.isFinished = function isFinished() {
+    return this.index >= this.len;
+  };
+
+  _proto.forwardN = function forwardN(n) {
+    for (var i = 0; i < n; i++) {
+      this.forward();
+    }
+  };
+
+  _proto.forward = function forward() {
+    this.index++;
+
+    if (this.previous() === '\n') {
+      this.lineno++;
+      this.colno = 0;
+    } else {
+      this.colno++;
+    }
+  };
+
+  _proto.backN = function backN(n) {
+    for (var i = 0; i < n; i++) {
+      this.back();
+    }
+  };
+
+  _proto.back = function back() {
+    this.index--;
+
+    if (this.current() === '\n') {
+      this.lineno--;
+      var idx = this.src.lastIndexOf('\n', this.index - 1);
+
+      if (idx === -1) {
+        this.colno = this.index;
+      } else {
+        this.colno = this.index - idx;
+      }
+    } else {
+      this.colno--;
+    }
+  } // current returns current character
+  ;
+
+  _proto.current = function current() {
+    if (!this.isFinished()) {
+      return this.str.charAt(this.index);
+    }
+
+    return '';
+  } // currentStr returns what's left of the unparsed string
+  ;
+
+  _proto.currentStr = function currentStr() {
+    if (!this.isFinished()) {
+      return this.str.substr(this.index);
+    }
+
+    return '';
+  };
+
+  _proto.previous = function previous() {
+    return this.str.charAt(this.index - 1);
+  };
+
+  return Tokenizer;
+}();
+
+module.exports = {
+  lex: function lex(src, opts) {
+    return new Tokenizer(src, opts);
+  },
+  TOKEN_STRING: TOKEN_STRING,
+  TOKEN_WHITESPACE: TOKEN_WHITESPACE,
+  TOKEN_DATA: TOKEN_DATA,
+  TOKEN_BLOCK_START: TOKEN_BLOCK_START,
+  TOKEN_BLOCK_END: TOKEN_BLOCK_END,
+  TOKEN_VARIABLE_START: TOKEN_VARIABLE_START,
+  TOKEN_VARIABLE_END: TOKEN_VARIABLE_END,
+  TOKEN_COMMENT: TOKEN_COMMENT,
+  TOKEN_LEFT_PAREN: TOKEN_LEFT_PAREN,
+  TOKEN_RIGHT_PAREN: TOKEN_RIGHT_PAREN,
+  TOKEN_LEFT_BRACKET: TOKEN_LEFT_BRACKET,
+  TOKEN_RIGHT_BRACKET: TOKEN_RIGHT_BRACKET,
+  TOKEN_LEFT_CURLY: TOKEN_LEFT_CURLY,
+  TOKEN_RIGHT_CURLY: TOKEN_RIGHT_CURLY,
+  TOKEN_OPERATOR: TOKEN_OPERATOR,
+  TOKEN_COMMA: TOKEN_COMMA,
+  TOKEN_COLON: TOKEN_COLON,
+  TOKEN_TILDE: TOKEN_TILDE,
+  TOKEN_PIPE: TOKEN_PIPE,
+  TOKEN_INT: TOKEN_INT,
+  TOKEN_FLOAT: TOKEN_FLOAT,
+  TOKEN_BOOLEAN: TOKEN_BOOLEAN,
+  TOKEN_NONE: TOKEN_NONE,
+  TOKEN_SYMBOL: TOKEN_SYMBOL,
+  TOKEN_SPECIAL: TOKEN_SPECIAL,
+  TOKEN_REGEX: TOKEN_REGEX
+};
+
+/***/ }),
+
+/***/ 4127:
+/***/ ((module) => {
+
+"use strict";
+
+
+var ArrayProto = Array.prototype;
+var ObjProto = Object.prototype;
+var escapeMap = {
+  '&': '&amp;',
+  '"': '&quot;',
+  '\'': '&#39;',
+  '<': '&lt;',
+  '>': '&gt;'
+};
+var escapeRegex = /[&"'<>]/g;
+
+var _exports = module.exports = {};
+
+function hasOwnProp(obj, k) {
+  return ObjProto.hasOwnProperty.call(obj, k);
+}
+
+_exports.hasOwnProp = hasOwnProp;
+
+function lookupEscape(ch) {
+  return escapeMap[ch];
+}
+
+function _prettifyError(path, withInternals, err) {
+  if (!err.Update) {
+    // not one of ours, cast it
+    err = new _exports.TemplateError(err);
+  }
+
+  err.Update(path); // Unless they marked the dev flag, show them a trace from here
+
+  if (!withInternals) {
+    var old = err;
+    err = new Error(old.message);
+    err.name = old.name;
+  }
+
+  return err;
+}
+
+_exports._prettifyError = _prettifyError;
+
+function TemplateError(message, lineno, colno) {
+  var err;
+  var cause;
+
+  if (message instanceof Error) {
+    cause = message;
+    message = cause.name + ": " + cause.message;
+  }
+
+  if (Object.setPrototypeOf) {
+    err = new Error(message);
+    Object.setPrototypeOf(err, TemplateError.prototype);
+  } else {
+    err = this;
+    Object.defineProperty(err, 'message', {
+      enumerable: false,
+      writable: true,
+      value: message
+    });
+  }
+
+  Object.defineProperty(err, 'name', {
+    value: 'Template render error'
+  });
+
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(err, this.constructor);
+  }
+
+  var getStack;
+
+  if (cause) {
+    var stackDescriptor = Object.getOwnPropertyDescriptor(cause, 'stack');
+
+    getStack = stackDescriptor && (stackDescriptor.get || function () {
+      return stackDescriptor.value;
+    });
+
+    if (!getStack) {
+      getStack = function getStack() {
+        return cause.stack;
+      };
+    }
+  } else {
+    var stack = new Error(message).stack;
+
+    getStack = function getStack() {
+      return stack;
+    };
+  }
+
+  Object.defineProperty(err, 'stack', {
+    get: function get() {
+      return getStack.call(err);
+    }
+  });
+  Object.defineProperty(err, 'cause', {
+    value: cause
+  });
+  err.lineno = lineno;
+  err.colno = colno;
+  err.firstUpdate = true;
+
+  err.Update = function Update(path) {
+    var msg = '(' + (path || 'unknown path') + ')'; // only show lineno + colno next to path of template
+    // where error occurred
+
+    if (this.firstUpdate) {
+      if (this.lineno && this.colno) {
+        msg += " [Line " + this.lineno + ", Column " + this.colno + "]";
+      } else if (this.lineno) {
+        msg += " [Line " + this.lineno + "]";
+      }
+    }
+
+    msg += '\n ';
+
+    if (this.firstUpdate) {
+      msg += ' ';
+    }
+
+    this.message = msg + (this.message || '');
+    this.firstUpdate = false;
+    return this;
+  };
+
+  return err;
+}
+
+if (Object.setPrototypeOf) {
+  Object.setPrototypeOf(TemplateError.prototype, Error.prototype);
+} else {
+  TemplateError.prototype = Object.create(Error.prototype, {
+    constructor: {
+      value: TemplateError
+    }
+  });
+}
+
+_exports.TemplateError = TemplateError;
+
+function escape(val) {
+  return val.replace(escapeRegex, lookupEscape);
+}
+
+_exports.escape = escape;
+
+function isFunction(obj) {
+  return ObjProto.toString.call(obj) === '[object Function]';
+}
+
+_exports.isFunction = isFunction;
+
+function isArray(obj) {
+  return ObjProto.toString.call(obj) === '[object Array]';
+}
+
+_exports.isArray = isArray;
+
+function isString(obj) {
+  return ObjProto.toString.call(obj) === '[object String]';
+}
+
+_exports.isString = isString;
+
+function isObject(obj) {
+  return ObjProto.toString.call(obj) === '[object Object]';
+}
+
+_exports.isObject = isObject;
+/**
+ * @param {string|number} attr
+ * @returns {(string|number)[]}
+ * @private
+ */
+
+function _prepareAttributeParts(attr) {
+  if (!attr) {
+    return [];
+  }
+
+  if (typeof attr === 'string') {
+    return attr.split('.');
+  }
+
+  return [attr];
+}
+/**
+ * @param {string}   attribute      Attribute value. Dots allowed.
+ * @returns {function(Object): *}
+ */
+
+
+function getAttrGetter(attribute) {
+  var parts = _prepareAttributeParts(attribute);
+
+  return function attrGetter(item) {
+    var _item = item;
+
+    for (var i = 0; i < parts.length; i++) {
+      var part = parts[i]; // If item is not an object, and we still got parts to handle, it means
+      // that something goes wrong. Just roll out to undefined in that case.
+
+      if (hasOwnProp(_item, part)) {
+        _item = _item[part];
+      } else {
+        return undefined;
+      }
+    }
+
+    return _item;
+  };
+}
+
+_exports.getAttrGetter = getAttrGetter;
+
+function groupBy(obj, val, throwOnUndefined) {
+  var result = {};
+  var iterator = isFunction(val) ? val : getAttrGetter(val);
+
+  for (var i = 0; i < obj.length; i++) {
+    var value = obj[i];
+    var key = iterator(value, i);
+
+    if (key === undefined && throwOnUndefined === true) {
+      throw new TypeError("groupby: attribute \"" + val + "\" resolved to undefined");
+    }
+
+    (result[key] || (result[key] = [])).push(value);
+  }
+
+  return result;
+}
+
+_exports.groupBy = groupBy;
+
+function toArray(obj) {
+  return Array.prototype.slice.call(obj);
+}
+
+_exports.toArray = toArray;
+
+function without(array) {
+  var result = [];
+
+  if (!array) {
+    return result;
+  }
+
+  var length = array.length;
+  var contains = toArray(arguments).slice(1);
+  var index = -1;
+
+  while (++index < length) {
+    if (indexOf(contains, array[index]) === -1) {
+      result.push(array[index]);
+    }
+  }
+
+  return result;
+}
+
+_exports.without = without;
+
+function repeat(char_, n) {
+  var str = '';
+
+  for (var i = 0; i < n; i++) {
+    str += char_;
+  }
+
+  return str;
+}
+
+_exports.repeat = repeat;
+
+function each(obj, func, context) {
+  if (obj == null) {
+    return;
+  }
+
+  if (ArrayProto.forEach && obj.forEach === ArrayProto.forEach) {
+    obj.forEach(func, context);
+  } else if (obj.length === +obj.length) {
+    for (var i = 0, l = obj.length; i < l; i++) {
+      func.call(context, obj[i], i, obj);
+    }
+  }
+}
+
+_exports.each = each;
+
+function map(obj, func) {
+  var results = [];
+
+  if (obj == null) {
+    return results;
+  }
+
+  if (ArrayProto.map && obj.map === ArrayProto.map) {
+    return obj.map(func);
+  }
+
+  for (var i = 0; i < obj.length; i++) {
+    results[results.length] = func(obj[i], i);
+  }
+
+  if (obj.length === +obj.length) {
+    results.length = obj.length;
+  }
+
+  return results;
+}
+
+_exports.map = map;
+
+function asyncIter(arr, iter, cb) {
+  var i = -1;
+
+  function next() {
+    i++;
+
+    if (i < arr.length) {
+      iter(arr[i], i, next, cb);
+    } else {
+      cb();
+    }
+  }
+
+  next();
+}
+
+_exports.asyncIter = asyncIter;
+
+function asyncFor(obj, iter, cb) {
+  var keys = keys_(obj || {});
+  var len = keys.length;
+  var i = -1;
+
+  function next() {
+    i++;
+    var k = keys[i];
+
+    if (i < len) {
+      iter(k, obj[k], i, len, next);
+    } else {
+      cb();
+    }
+  }
+
+  next();
+}
+
+_exports.asyncFor = asyncFor;
+
+function indexOf(arr, searchElement, fromIndex) {
+  return Array.prototype.indexOf.call(arr || [], searchElement, fromIndex);
+}
+
+_exports.indexOf = indexOf;
+
+function keys_(obj) {
+  /* eslint-disable no-restricted-syntax */
+  var arr = [];
+
+  for (var k in obj) {
+    if (hasOwnProp(obj, k)) {
+      arr.push(k);
+    }
+  }
+
+  return arr;
+}
+
+_exports.keys = keys_;
+
+function _entries(obj) {
+  return keys_(obj).map(function (k) {
+    return [k, obj[k]];
+  });
+}
+
+_exports._entries = _entries;
+
+function _values(obj) {
+  return keys_(obj).map(function (k) {
+    return obj[k];
+  });
+}
+
+_exports._values = _values;
+
+function extend(obj1, obj2) {
+  obj1 = obj1 || {};
+  keys_(obj2).forEach(function (k) {
+    obj1[k] = obj2[k];
+  });
+  return obj1;
+}
+
+_exports._assign = _exports.extend = extend;
+
+function inOperator(key, val) {
+  if (isArray(val) || isString(val)) {
+    return val.indexOf(key) !== -1;
+  } else if (isObject(val)) {
+    return key in val;
+  }
+
+  throw new Error('Cannot use "in" operator to search for "' + key + '" in unexpected types.');
+}
+
+_exports.inOperator = inOperator;
+
+/***/ }),
+
+/***/ 6981:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+var path = __nccwpck_require__(1017);
+
+var _require = __nccwpck_require__(7007),
+    EmitterObj = _require.EmitterObj;
+
+module.exports = /*#__PURE__*/function (_EmitterObj) {
+  _inheritsLoose(Loader, _EmitterObj);
+
+  function Loader() {
+    return _EmitterObj.apply(this, arguments) || this;
+  }
+
+  var _proto = Loader.prototype;
+
+  _proto.resolve = function resolve(from, to) {
+    return path.resolve(path.dirname(from), to);
+  };
+
+  _proto.isRelative = function isRelative(filename) {
+    return filename.indexOf('./') === 0 || filename.indexOf('../') === 0;
+  };
+
+  return Loader;
+}(EmitterObj);
+
+/***/ }),
+
+/***/ 4395:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+// This file will automatically be rewired to web-loader.js when
+// building for the browser
+module.exports = __nccwpck_require__(9082);
+
+/***/ }),
+
+/***/ 9082:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+/* eslint-disable no-console */
+
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+var fs = __nccwpck_require__(7147);
+
+var path = __nccwpck_require__(1017);
+
+var Loader = __nccwpck_require__(6981);
+
+var _require = __nccwpck_require__(8957),
+    PrecompiledLoader = _require.PrecompiledLoader;
+
+var chokidar;
+
+var FileSystemLoader = /*#__PURE__*/function (_Loader) {
+  _inheritsLoose(FileSystemLoader, _Loader);
+
+  function FileSystemLoader(searchPaths, opts) {
+    var _this;
+
+    _this = _Loader.call(this) || this;
+
+    if (typeof opts === 'boolean') {
+      console.log('[nunjucks] Warning: you passed a boolean as the second ' + 'argument to FileSystemLoader, but it now takes an options ' + 'object. See http://mozilla.github.io/nunjucks/api.html#filesystemloader');
+    }
+
+    opts = opts || {};
+    _this.pathsToNames = {};
+    _this.noCache = !!opts.noCache;
+
+    if (searchPaths) {
+      searchPaths = Array.isArray(searchPaths) ? searchPaths : [searchPaths]; // For windows, convert to forward slashes
+
+      _this.searchPaths = searchPaths.map(path.normalize);
+    } else {
+      _this.searchPaths = ['.'];
+    }
+
+    if (opts.watch) {
+      // Watch all the templates in the paths and fire an event when
+      // they change
+      try {
+        chokidar = __nccwpck_require__(561); // eslint-disable-line global-require
+      } catch (e) {
+        throw new Error('watch requires chokidar to be installed');
+      }
+
+      var paths = _this.searchPaths.filter(fs.existsSync);
+
+      var watcher = chokidar.watch(paths);
+      watcher.on('all', function (event, fullname) {
+        fullname = path.resolve(fullname);
+
+        if (event === 'change' && fullname in _this.pathsToNames) {
+          _this.emit('update', _this.pathsToNames[fullname], fullname);
+        }
+      });
+      watcher.on('error', function (error) {
+        console.log('Watcher error: ' + error);
+      });
+    }
+
+    return _this;
+  }
+
+  var _proto = FileSystemLoader.prototype;
+
+  _proto.getSource = function getSource(name) {
+    var fullpath = null;
+    var paths = this.searchPaths;
+
+    for (var i = 0; i < paths.length; i++) {
+      var basePath = path.resolve(paths[i]);
+      var p = path.resolve(paths[i], name); // Only allow the current directory and anything
+      // underneath it to be searched
+
+      if (p.indexOf(basePath) === 0 && fs.existsSync(p)) {
+        fullpath = p;
+        break;
+      }
+    }
+
+    if (!fullpath) {
+      return null;
+    }
+
+    this.pathsToNames[fullpath] = name;
+    var source = {
+      src: fs.readFileSync(fullpath, 'utf-8'),
+      path: fullpath,
+      noCache: this.noCache
+    };
+    this.emit('load', name, source);
+    return source;
+  };
+
+  return FileSystemLoader;
+}(Loader);
+
+var NodeResolveLoader = /*#__PURE__*/function (_Loader2) {
+  _inheritsLoose(NodeResolveLoader, _Loader2);
+
+  function NodeResolveLoader(opts) {
+    var _this2;
+
+    _this2 = _Loader2.call(this) || this;
+    opts = opts || {};
+    _this2.pathsToNames = {};
+    _this2.noCache = !!opts.noCache;
+
+    if (opts.watch) {
+      try {
+        chokidar = __nccwpck_require__(561); // eslint-disable-line global-require
+      } catch (e) {
+        throw new Error('watch requires chokidar to be installed');
+      }
+
+      _this2.watcher = chokidar.watch();
+
+      _this2.watcher.on('change', function (fullname) {
+        _this2.emit('update', _this2.pathsToNames[fullname], fullname);
+      });
+
+      _this2.watcher.on('error', function (error) {
+        console.log('Watcher error: ' + error);
+      });
+
+      _this2.on('load', function (name, source) {
+        _this2.watcher.add(source.path);
+      });
+    }
+
+    return _this2;
+  }
+
+  var _proto2 = NodeResolveLoader.prototype;
+
+  _proto2.getSource = function getSource(name) {
+    // Don't allow file-system traversal
+    if (/^\.?\.?(\/|\\)/.test(name)) {
+      return null;
+    }
+
+    if (/^[A-Z]:/.test(name)) {
+      return null;
+    }
+
+    var fullpath;
+
+    try {
+      fullpath = require.resolve(name);
+    } catch (e) {
+      return null;
+    }
+
+    this.pathsToNames[fullpath] = name;
+    var source = {
+      src: fs.readFileSync(fullpath, 'utf-8'),
+      path: fullpath,
+      noCache: this.noCache
+    };
+    this.emit('load', name, source);
+    return source;
+  };
+
+  return NodeResolveLoader;
+}(Loader);
+
+module.exports = {
+  FileSystemLoader: FileSystemLoader,
+  PrecompiledLoader: PrecompiledLoader,
+  NodeResolveLoader: NodeResolveLoader
+};
+
+/***/ }),
+
+/***/ 429:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+var _require = __nccwpck_require__(7007),
+    Obj = _require.Obj;
+
+function traverseAndCheck(obj, type, results) {
+  if (obj instanceof type) {
+    results.push(obj);
+  }
+
+  if (obj instanceof Node) {
+    obj.findAll(type, results);
+  }
+}
+
+var Node = /*#__PURE__*/function (_Obj) {
+  _inheritsLoose(Node, _Obj);
+
+  function Node() {
+    return _Obj.apply(this, arguments) || this;
+  }
+
+  var _proto = Node.prototype;
+
+  _proto.init = function init(lineno, colno) {
+    var _arguments = arguments,
+        _this = this;
+
+    for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+      args[_key - 2] = arguments[_key];
+    }
+
+    this.lineno = lineno;
+    this.colno = colno;
+    this.fields.forEach(function (field, i) {
+      // The first two args are line/col numbers, so offset by 2
+      var val = _arguments[i + 2]; // Fields should never be undefined, but null. It makes
+      // testing easier to normalize values.
+
+      if (val === undefined) {
+        val = null;
+      }
+
+      _this[field] = val;
+    });
+  };
+
+  _proto.findAll = function findAll(type, results) {
+    var _this2 = this;
+
+    results = results || [];
+
+    if (this instanceof NodeList) {
+      this.children.forEach(function (child) {
+        return traverseAndCheck(child, type, results);
+      });
+    } else {
+      this.fields.forEach(function (field) {
+        return traverseAndCheck(_this2[field], type, results);
+      });
+    }
+
+    return results;
+  };
+
+  _proto.iterFields = function iterFields(func) {
+    var _this3 = this;
+
+    this.fields.forEach(function (field) {
+      func(_this3[field], field);
+    });
+  };
+
+  return Node;
+}(Obj); // Abstract nodes
+
+
+var Value = /*#__PURE__*/function (_Node) {
+  _inheritsLoose(Value, _Node);
+
+  function Value() {
+    return _Node.apply(this, arguments) || this;
+  }
+
+  _createClass(Value, [{
+    key: "typename",
+    get: function get() {
+      return 'Value';
+    }
+  }, {
+    key: "fields",
+    get: function get() {
+      return ['value'];
+    }
+  }]);
+
+  return Value;
+}(Node); // Concrete nodes
+
+
+var NodeList = /*#__PURE__*/function (_Node2) {
+  _inheritsLoose(NodeList, _Node2);
+
+  function NodeList() {
+    return _Node2.apply(this, arguments) || this;
+  }
+
+  var _proto2 = NodeList.prototype;
+
+  _proto2.init = function init(lineno, colno, nodes) {
+    _Node2.prototype.init.call(this, lineno, colno, nodes || []);
+  };
+
+  _proto2.addChild = function addChild(node) {
+    this.children.push(node);
+  };
+
+  _createClass(NodeList, [{
+    key: "typename",
+    get: function get() {
+      return 'NodeList';
+    }
+  }, {
+    key: "fields",
+    get: function get() {
+      return ['children'];
+    }
+  }]);
+
+  return NodeList;
+}(Node);
+
+var Root = NodeList.extend('Root');
+var Literal = Value.extend('Literal');
+var Symbol = Value.extend('Symbol');
+var Group = NodeList.extend('Group');
+var ArrayNode = NodeList.extend('Array');
+var Pair = Node.extend('Pair', {
+  fields: ['key', 'value']
+});
+var Dict = NodeList.extend('Dict');
+var LookupVal = Node.extend('LookupVal', {
+  fields: ['target', 'val']
+});
+var If = Node.extend('If', {
+  fields: ['cond', 'body', 'else_']
+});
+var IfAsync = If.extend('IfAsync');
+var InlineIf = Node.extend('InlineIf', {
+  fields: ['cond', 'body', 'else_']
+});
+var For = Node.extend('For', {
+  fields: ['arr', 'name', 'body', 'else_']
+});
+var AsyncEach = For.extend('AsyncEach');
+var AsyncAll = For.extend('AsyncAll');
+var Macro = Node.extend('Macro', {
+  fields: ['name', 'args', 'body']
+});
+var Caller = Macro.extend('Caller');
+var Import = Node.extend('Import', {
+  fields: ['template', 'target', 'withContext']
+});
+
+var FromImport = /*#__PURE__*/function (_Node3) {
+  _inheritsLoose(FromImport, _Node3);
+
+  function FromImport() {
+    return _Node3.apply(this, arguments) || this;
+  }
+
+  var _proto3 = FromImport.prototype;
+
+  _proto3.init = function init(lineno, colno, template, names, withContext) {
+    _Node3.prototype.init.call(this, lineno, colno, template, names || new NodeList(), withContext);
+  };
+
+  _createClass(FromImport, [{
+    key: "typename",
+    get: function get() {
+      return 'FromImport';
+    }
+  }, {
+    key: "fields",
+    get: function get() {
+      return ['template', 'names', 'withContext'];
+    }
+  }]);
+
+  return FromImport;
+}(Node);
+
+var FunCall = Node.extend('FunCall', {
+  fields: ['name', 'args']
+});
+var Filter = FunCall.extend('Filter');
+var FilterAsync = Filter.extend('FilterAsync', {
+  fields: ['name', 'args', 'symbol']
+});
+var KeywordArgs = Dict.extend('KeywordArgs');
+var Block = Node.extend('Block', {
+  fields: ['name', 'body']
+});
+var Super = Node.extend('Super', {
+  fields: ['blockName', 'symbol']
+});
+var TemplateRef = Node.extend('TemplateRef', {
+  fields: ['template']
+});
+var Extends = TemplateRef.extend('Extends');
+var Include = Node.extend('Include', {
+  fields: ['template', 'ignoreMissing']
+});
+var Set = Node.extend('Set', {
+  fields: ['targets', 'value']
+});
+var Switch = Node.extend('Switch', {
+  fields: ['expr', 'cases', 'default']
+});
+var Case = Node.extend('Case', {
+  fields: ['cond', 'body']
+});
+var Output = NodeList.extend('Output');
+var Capture = Node.extend('Capture', {
+  fields: ['body']
+});
+var TemplateData = Literal.extend('TemplateData');
+var UnaryOp = Node.extend('UnaryOp', {
+  fields: ['target']
+});
+var BinOp = Node.extend('BinOp', {
+  fields: ['left', 'right']
+});
+var In = BinOp.extend('In');
+var Is = BinOp.extend('Is');
+var Or = BinOp.extend('Or');
+var And = BinOp.extend('And');
+var Not = UnaryOp.extend('Not');
+var Add = BinOp.extend('Add');
+var Concat = BinOp.extend('Concat');
+var Sub = BinOp.extend('Sub');
+var Mul = BinOp.extend('Mul');
+var Div = BinOp.extend('Div');
+var FloorDiv = BinOp.extend('FloorDiv');
+var Mod = BinOp.extend('Mod');
+var Pow = BinOp.extend('Pow');
+var Neg = UnaryOp.extend('Neg');
+var Pos = UnaryOp.extend('Pos');
+var Compare = Node.extend('Compare', {
+  fields: ['expr', 'ops']
+});
+var CompareOperand = Node.extend('CompareOperand', {
+  fields: ['expr', 'type']
+});
+var CallExtension = Node.extend('CallExtension', {
+  init: function init(ext, prop, args, contentArgs) {
+    this.parent();
+    this.extName = ext.__name || ext;
+    this.prop = prop;
+    this.args = args || new NodeList();
+    this.contentArgs = contentArgs || [];
+    this.autoescape = ext.autoescape;
+  },
+  fields: ['extName', 'prop', 'args', 'contentArgs']
+});
+var CallExtensionAsync = CallExtension.extend('CallExtensionAsync'); // This is hacky, but this is just a debugging function anyway
+
+function print(str, indent, inline) {
+  var lines = str.split('\n');
+  lines.forEach(function (line, i) {
+    if (line && (inline && i > 0 || !inline)) {
+      process.stdout.write(' '.repeat(indent));
+    }
+
+    var nl = i === lines.length - 1 ? '' : '\n';
+    process.stdout.write("" + line + nl);
+  });
+} // Print the AST in a nicely formatted tree format for debuggin
+
+
+function printNodes(node, indent) {
+  indent = indent || 0;
+  print(node.typename + ': ', indent);
+
+  if (node instanceof NodeList) {
+    print('\n');
+    node.children.forEach(function (n) {
+      printNodes(n, indent + 2);
+    });
+  } else if (node instanceof CallExtension) {
+    print(node.extName + "." + node.prop + "\n");
+
+    if (node.args) {
+      printNodes(node.args, indent + 2);
+    }
+
+    if (node.contentArgs) {
+      node.contentArgs.forEach(function (n) {
+        printNodes(n, indent + 2);
+      });
+    }
+  } else {
+    var nodes = [];
+    var props = null;
+    node.iterFields(function (val, fieldName) {
+      if (val instanceof Node) {
+        nodes.push([fieldName, val]);
+      } else {
+        props = props || {};
+        props[fieldName] = val;
+      }
+    });
+
+    if (props) {
+      print(JSON.stringify(props, null, 2) + '\n', null, true);
+    } else {
+      print('\n');
+    }
+
+    nodes.forEach(function (_ref) {
+      var fieldName = _ref[0],
+          n = _ref[1];
+      print("[" + fieldName + "] =>", indent + 2);
+      printNodes(n, indent + 4);
+    });
+  }
+}
+
+module.exports = {
+  Node: Node,
+  Root: Root,
+  NodeList: NodeList,
+  Value: Value,
+  Literal: Literal,
+  Symbol: Symbol,
+  Group: Group,
+  Array: ArrayNode,
+  Pair: Pair,
+  Dict: Dict,
+  Output: Output,
+  Capture: Capture,
+  TemplateData: TemplateData,
+  If: If,
+  IfAsync: IfAsync,
+  InlineIf: InlineIf,
+  For: For,
+  AsyncEach: AsyncEach,
+  AsyncAll: AsyncAll,
+  Macro: Macro,
+  Caller: Caller,
+  Import: Import,
+  FromImport: FromImport,
+  FunCall: FunCall,
+  Filter: Filter,
+  FilterAsync: FilterAsync,
+  KeywordArgs: KeywordArgs,
+  Block: Block,
+  Super: Super,
+  Extends: Extends,
+  Include: Include,
+  Set: Set,
+  Switch: Switch,
+  Case: Case,
+  LookupVal: LookupVal,
+  BinOp: BinOp,
+  In: In,
+  Is: Is,
+  Or: Or,
+  And: And,
+  Not: Not,
+  Add: Add,
+  Concat: Concat,
+  Sub: Sub,
+  Mul: Mul,
+  Div: Div,
+  FloorDiv: FloorDiv,
+  Mod: Mod,
+  Pow: Pow,
+  Neg: Neg,
+  Pos: Pos,
+  Compare: Compare,
+  CompareOperand: CompareOperand,
+  CallExtension: CallExtension,
+  CallExtensionAsync: CallExtensionAsync,
+  printNodes: printNodes
+};
+
+/***/ }),
+
+/***/ 7007:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+ // A simple class system, more documentation to come
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+var EventEmitter = __nccwpck_require__(2361);
+
+var lib = __nccwpck_require__(4127);
+
+function parentWrap(parent, prop) {
+  if (typeof parent !== 'function' || typeof prop !== 'function') {
+    return prop;
+  }
+
+  return function wrap() {
+    // Save the current parent method
+    var tmp = this.parent; // Set parent to the previous method, call, and restore
+
+    this.parent = parent;
+    var res = prop.apply(this, arguments);
+    this.parent = tmp;
+    return res;
+  };
+}
+
+function extendClass(cls, name, props) {
+  props = props || {};
+  lib.keys(props).forEach(function (k) {
+    props[k] = parentWrap(cls.prototype[k], props[k]);
+  });
+
+  var subclass = /*#__PURE__*/function (_cls) {
+    _inheritsLoose(subclass, _cls);
+
+    function subclass() {
+      return _cls.apply(this, arguments) || this;
+    }
+
+    _createClass(subclass, [{
+      key: "typename",
+      get: function get() {
+        return name;
+      }
+    }]);
+
+    return subclass;
+  }(cls);
+
+  lib._assign(subclass.prototype, props);
+
+  return subclass;
+}
+
+var Obj = /*#__PURE__*/function () {
+  function Obj() {
+    // Unfortunately necessary for backwards compatibility
+    this.init.apply(this, arguments);
+  }
+
+  var _proto = Obj.prototype;
+
+  _proto.init = function init() {};
+
+  Obj.extend = function extend(name, props) {
+    if (typeof name === 'object') {
+      props = name;
+      name = 'anonymous';
+    }
+
+    return extendClass(this, name, props);
+  };
+
+  _createClass(Obj, [{
+    key: "typename",
+    get: function get() {
+      return this.constructor.name;
+    }
+  }]);
+
+  return Obj;
+}();
+
+var EmitterObj = /*#__PURE__*/function (_EventEmitter) {
+  _inheritsLoose(EmitterObj, _EventEmitter);
+
+  function EmitterObj() {
+    var _this2;
+
+    var _this;
+
+    _this = _EventEmitter.call(this) || this; // Unfortunately necessary for backwards compatibility
+
+    (_this2 = _this).init.apply(_this2, arguments);
+
+    return _this;
+  }
+
+  var _proto2 = EmitterObj.prototype;
+
+  _proto2.init = function init() {};
+
+  EmitterObj.extend = function extend(name, props) {
+    if (typeof name === 'object') {
+      props = name;
+      name = 'anonymous';
+    }
+
+    return extendClass(this, name, props);
+  };
+
+  _createClass(EmitterObj, [{
+    key: "typename",
+    get: function get() {
+      return this.constructor.name;
+    }
+  }]);
+
+  return EmitterObj;
+}(EventEmitter);
+
+module.exports = {
+  Obj: Obj,
+  EmitterObj: EmitterObj
+};
+
+/***/ }),
+
+/***/ 6614:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+var lexer = __nccwpck_require__(3158);
+
+var nodes = __nccwpck_require__(429);
+
+var Obj = (__nccwpck_require__(7007).Obj);
+
+var lib = __nccwpck_require__(4127);
+
+var Parser = /*#__PURE__*/function (_Obj) {
+  _inheritsLoose(Parser, _Obj);
+
+  function Parser() {
+    return _Obj.apply(this, arguments) || this;
+  }
+
+  var _proto = Parser.prototype;
+
+  _proto.init = function init(tokens) {
+    this.tokens = tokens;
+    this.peeked = null;
+    this.breakOnBlocks = null;
+    this.dropLeadingWhitespace = false;
+    this.extensions = [];
+  };
+
+  _proto.nextToken = function nextToken(withWhitespace) {
+    var tok;
+
+    if (this.peeked) {
+      if (!withWhitespace && this.peeked.type === lexer.TOKEN_WHITESPACE) {
+        this.peeked = null;
+      } else {
+        tok = this.peeked;
+        this.peeked = null;
+        return tok;
+      }
+    }
+
+    tok = this.tokens.nextToken();
+
+    if (!withWhitespace) {
+      while (tok && tok.type === lexer.TOKEN_WHITESPACE) {
+        tok = this.tokens.nextToken();
+      }
+    }
+
+    return tok;
+  };
+
+  _proto.peekToken = function peekToken() {
+    this.peeked = this.peeked || this.nextToken();
+    return this.peeked;
+  };
+
+  _proto.pushToken = function pushToken(tok) {
+    if (this.peeked) {
+      throw new Error('pushToken: can only push one token on between reads');
+    }
+
+    this.peeked = tok;
+  };
+
+  _proto.error = function error(msg, lineno, colno) {
+    if (lineno === undefined || colno === undefined) {
+      var tok = this.peekToken() || {};
+      lineno = tok.lineno;
+      colno = tok.colno;
+    }
+
+    if (lineno !== undefined) {
+      lineno += 1;
+    }
+
+    if (colno !== undefined) {
+      colno += 1;
+    }
+
+    return new lib.TemplateError(msg, lineno, colno);
+  };
+
+  _proto.fail = function fail(msg, lineno, colno) {
+    throw this.error(msg, lineno, colno);
+  };
+
+  _proto.skip = function skip(type) {
+    var tok = this.nextToken();
+
+    if (!tok || tok.type !== type) {
+      this.pushToken(tok);
+      return false;
+    }
+
+    return true;
+  };
+
+  _proto.expect = function expect(type) {
+    var tok = this.nextToken();
+
+    if (tok.type !== type) {
+      this.fail('expected ' + type + ', got ' + tok.type, tok.lineno, tok.colno);
+    }
+
+    return tok;
+  };
+
+  _proto.skipValue = function skipValue(type, val) {
+    var tok = this.nextToken();
+
+    if (!tok || tok.type !== type || tok.value !== val) {
+      this.pushToken(tok);
+      return false;
+    }
+
+    return true;
+  };
+
+  _proto.skipSymbol = function skipSymbol(val) {
+    return this.skipValue(lexer.TOKEN_SYMBOL, val);
+  };
+
+  _proto.advanceAfterBlockEnd = function advanceAfterBlockEnd(name) {
+    var tok;
+
+    if (!name) {
+      tok = this.peekToken();
+
+      if (!tok) {
+        this.fail('unexpected end of file');
+      }
+
+      if (tok.type !== lexer.TOKEN_SYMBOL) {
+        this.fail('advanceAfterBlockEnd: expected symbol token or ' + 'explicit name to be passed');
+      }
+
+      name = this.nextToken().value;
+    }
+
+    tok = this.nextToken();
+
+    if (tok && tok.type === lexer.TOKEN_BLOCK_END) {
+      if (tok.value.charAt(0) === '-') {
+        this.dropLeadingWhitespace = true;
+      }
+    } else {
+      this.fail('expected block end in ' + name + ' statement');
+    }
+
+    return tok;
+  };
+
+  _proto.advanceAfterVariableEnd = function advanceAfterVariableEnd() {
+    var tok = this.nextToken();
+
+    if (tok && tok.type === lexer.TOKEN_VARIABLE_END) {
+      this.dropLeadingWhitespace = tok.value.charAt(tok.value.length - this.tokens.tags.VARIABLE_END.length - 1) === '-';
+    } else {
+      this.pushToken(tok);
+      this.fail('expected variable end');
+    }
+  };
+
+  _proto.parseFor = function parseFor() {
+    var forTok = this.peekToken();
+    var node;
+    var endBlock;
+
+    if (this.skipSymbol('for')) {
+      node = new nodes.For(forTok.lineno, forTok.colno);
+      endBlock = 'endfor';
+    } else if (this.skipSymbol('asyncEach')) {
+      node = new nodes.AsyncEach(forTok.lineno, forTok.colno);
+      endBlock = 'endeach';
+    } else if (this.skipSymbol('asyncAll')) {
+      node = new nodes.AsyncAll(forTok.lineno, forTok.colno);
+      endBlock = 'endall';
+    } else {
+      this.fail('parseFor: expected for{Async}', forTok.lineno, forTok.colno);
+    }
+
+    node.name = this.parsePrimary();
+
+    if (!(node.name instanceof nodes.Symbol)) {
+      this.fail('parseFor: variable name expected for loop');
+    }
+
+    var type = this.peekToken().type;
+
+    if (type === lexer.TOKEN_COMMA) {
+      // key/value iteration
+      var key = node.name;
+      node.name = new nodes.Array(key.lineno, key.colno);
+      node.name.addChild(key);
+
+      while (this.skip(lexer.TOKEN_COMMA)) {
+        var prim = this.parsePrimary();
+        node.name.addChild(prim);
+      }
+    }
+
+    if (!this.skipSymbol('in')) {
+      this.fail('parseFor: expected "in" keyword for loop', forTok.lineno, forTok.colno);
+    }
+
+    node.arr = this.parseExpression();
+    this.advanceAfterBlockEnd(forTok.value);
+    node.body = this.parseUntilBlocks(endBlock, 'else');
+
+    if (this.skipSymbol('else')) {
+      this.advanceAfterBlockEnd('else');
+      node.else_ = this.parseUntilBlocks(endBlock);
+    }
+
+    this.advanceAfterBlockEnd();
+    return node;
+  };
+
+  _proto.parseMacro = function parseMacro() {
+    var macroTok = this.peekToken();
+
+    if (!this.skipSymbol('macro')) {
+      this.fail('expected macro');
+    }
+
+    var name = this.parsePrimary(true);
+    var args = this.parseSignature();
+    var node = new nodes.Macro(macroTok.lineno, macroTok.colno, name, args);
+    this.advanceAfterBlockEnd(macroTok.value);
+    node.body = this.parseUntilBlocks('endmacro');
+    this.advanceAfterBlockEnd();
+    return node;
+  };
+
+  _proto.parseCall = function parseCall() {
+    // a call block is parsed as a normal FunCall, but with an added
+    // 'caller' kwarg which is a Caller node.
+    var callTok = this.peekToken();
+
+    if (!this.skipSymbol('call')) {
+      this.fail('expected call');
+    }
+
+    var callerArgs = this.parseSignature(true) || new nodes.NodeList();
+    var macroCall = this.parsePrimary();
+    this.advanceAfterBlockEnd(callTok.value);
+    var body = this.parseUntilBlocks('endcall');
+    this.advanceAfterBlockEnd();
+    var callerName = new nodes.Symbol(callTok.lineno, callTok.colno, 'caller');
+    var callerNode = new nodes.Caller(callTok.lineno, callTok.colno, callerName, callerArgs, body); // add the additional caller kwarg, adding kwargs if necessary
+
+    var args = macroCall.args.children;
+
+    if (!(args[args.length - 1] instanceof nodes.KeywordArgs)) {
+      args.push(new nodes.KeywordArgs());
+    }
+
+    var kwargs = args[args.length - 1];
+    kwargs.addChild(new nodes.Pair(callTok.lineno, callTok.colno, callerName, callerNode));
+    return new nodes.Output(callTok.lineno, callTok.colno, [macroCall]);
+  };
+
+  _proto.parseWithContext = function parseWithContext() {
+    var tok = this.peekToken();
+    var withContext = null;
+
+    if (this.skipSymbol('with')) {
+      withContext = true;
+    } else if (this.skipSymbol('without')) {
+      withContext = false;
+    }
+
+    if (withContext !== null) {
+      if (!this.skipSymbol('context')) {
+        this.fail('parseFrom: expected context after with/without', tok.lineno, tok.colno);
+      }
+    }
+
+    return withContext;
+  };
+
+  _proto.parseImport = function parseImport() {
+    var importTok = this.peekToken();
+
+    if (!this.skipSymbol('import')) {
+      this.fail('parseImport: expected import', importTok.lineno, importTok.colno);
+    }
+
+    var template = this.parseExpression();
+
+    if (!this.skipSymbol('as')) {
+      this.fail('parseImport: expected "as" keyword', importTok.lineno, importTok.colno);
+    }
+
+    var target = this.parseExpression();
+    var withContext = this.parseWithContext();
+    var node = new nodes.Import(importTok.lineno, importTok.colno, template, target, withContext);
+    this.advanceAfterBlockEnd(importTok.value);
+    return node;
+  };
+
+  _proto.parseFrom = function parseFrom() {
+    var fromTok = this.peekToken();
+
+    if (!this.skipSymbol('from')) {
+      this.fail('parseFrom: expected from');
+    }
+
+    var template = this.parseExpression();
+
+    if (!this.skipSymbol('import')) {
+      this.fail('parseFrom: expected import', fromTok.lineno, fromTok.colno);
+    }
+
+    var names = new nodes.NodeList();
+    var withContext;
+
+    while (1) {
+      // eslint-disable-line no-constant-condition
+      var nextTok = this.peekToken();
+
+      if (nextTok.type === lexer.TOKEN_BLOCK_END) {
+        if (!names.children.length) {
+          this.fail('parseFrom: Expected at least one import name', fromTok.lineno, fromTok.colno);
+        } // Since we are manually advancing past the block end,
+        // need to keep track of whitespace control (normally
+        // this is done in `advanceAfterBlockEnd`
+
+
+        if (nextTok.value.charAt(0) === '-') {
+          this.dropLeadingWhitespace = true;
+        }
+
+        this.nextToken();
+        break;
+      }
+
+      if (names.children.length > 0 && !this.skip(lexer.TOKEN_COMMA)) {
+        this.fail('parseFrom: expected comma', fromTok.lineno, fromTok.colno);
+      }
+
+      var name = this.parsePrimary();
+
+      if (name.value.charAt(0) === '_') {
+        this.fail('parseFrom: names starting with an underscore cannot be imported', name.lineno, name.colno);
+      }
+
+      if (this.skipSymbol('as')) {
+        var alias = this.parsePrimary();
+        names.addChild(new nodes.Pair(name.lineno, name.colno, name, alias));
+      } else {
+        names.addChild(name);
+      }
+
+      withContext = this.parseWithContext();
+    }
+
+    return new nodes.FromImport(fromTok.lineno, fromTok.colno, template, names, withContext);
+  };
+
+  _proto.parseBlock = function parseBlock() {
+    var tag = this.peekToken();
+
+    if (!this.skipSymbol('block')) {
+      this.fail('parseBlock: expected block', tag.lineno, tag.colno);
+    }
+
+    var node = new nodes.Block(tag.lineno, tag.colno);
+    node.name = this.parsePrimary();
+
+    if (!(node.name instanceof nodes.Symbol)) {
+      this.fail('parseBlock: variable name expected', tag.lineno, tag.colno);
+    }
+
+    this.advanceAfterBlockEnd(tag.value);
+    node.body = this.parseUntilBlocks('endblock');
+    this.skipSymbol('endblock');
+    this.skipSymbol(node.name.value);
+    var tok = this.peekToken();
+
+    if (!tok) {
+      this.fail('parseBlock: expected endblock, got end of file');
+    }
+
+    this.advanceAfterBlockEnd(tok.value);
+    return node;
+  };
+
+  _proto.parseExtends = function parseExtends() {
+    var tagName = 'extends';
+    var tag = this.peekToken();
+
+    if (!this.skipSymbol(tagName)) {
+      this.fail('parseTemplateRef: expected ' + tagName);
+    }
+
+    var node = new nodes.Extends(tag.lineno, tag.colno);
+    node.template = this.parseExpression();
+    this.advanceAfterBlockEnd(tag.value);
+    return node;
+  };
+
+  _proto.parseInclude = function parseInclude() {
+    var tagName = 'include';
+    var tag = this.peekToken();
+
+    if (!this.skipSymbol(tagName)) {
+      this.fail('parseInclude: expected ' + tagName);
+    }
+
+    var node = new nodes.Include(tag.lineno, tag.colno);
+    node.template = this.parseExpression();
+
+    if (this.skipSymbol('ignore') && this.skipSymbol('missing')) {
+      node.ignoreMissing = true;
+    }
+
+    this.advanceAfterBlockEnd(tag.value);
+    return node;
+  };
+
+  _proto.parseIf = function parseIf() {
+    var tag = this.peekToken();
+    var node;
+
+    if (this.skipSymbol('if') || this.skipSymbol('elif') || this.skipSymbol('elseif')) {
+      node = new nodes.If(tag.lineno, tag.colno);
+    } else if (this.skipSymbol('ifAsync')) {
+      node = new nodes.IfAsync(tag.lineno, tag.colno);
+    } else {
+      this.fail('parseIf: expected if, elif, or elseif', tag.lineno, tag.colno);
+    }
+
+    node.cond = this.parseExpression();
+    this.advanceAfterBlockEnd(tag.value);
+    node.body = this.parseUntilBlocks('elif', 'elseif', 'else', 'endif');
+    var tok = this.peekToken();
+
+    switch (tok && tok.value) {
+      case 'elseif':
+      case 'elif':
+        node.else_ = this.parseIf();
+        break;
+
+      case 'else':
+        this.advanceAfterBlockEnd();
+        node.else_ = this.parseUntilBlocks('endif');
+        this.advanceAfterBlockEnd();
+        break;
+
+      case 'endif':
+        node.else_ = null;
+        this.advanceAfterBlockEnd();
+        break;
+
+      default:
+        this.fail('parseIf: expected elif, else, or endif, got end of file');
+    }
+
+    return node;
+  };
+
+  _proto.parseSet = function parseSet() {
+    var tag = this.peekToken();
+
+    if (!this.skipSymbol('set')) {
+      this.fail('parseSet: expected set', tag.lineno, tag.colno);
+    }
+
+    var node = new nodes.Set(tag.lineno, tag.colno, []);
+    var target;
+
+    while (target = this.parsePrimary()) {
+      node.targets.push(target);
+
+      if (!this.skip(lexer.TOKEN_COMMA)) {
+        break;
+      }
+    }
+
+    if (!this.skipValue(lexer.TOKEN_OPERATOR, '=')) {
+      if (!this.skip(lexer.TOKEN_BLOCK_END)) {
+        this.fail('parseSet: expected = or block end in set tag', tag.lineno, tag.colno);
+      } else {
+        node.body = new nodes.Capture(tag.lineno, tag.colno, this.parseUntilBlocks('endset'));
+        node.value = null;
+        this.advanceAfterBlockEnd();
+      }
+    } else {
+      node.value = this.parseExpression();
+      this.advanceAfterBlockEnd(tag.value);
+    }
+
+    return node;
+  };
+
+  _proto.parseSwitch = function parseSwitch() {
+    /*
+     * Store the tag names in variables in case someone ever wants to
+     * customize this.
+     */
+    var switchStart = 'switch';
+    var switchEnd = 'endswitch';
+    var caseStart = 'case';
+    var caseDefault = 'default'; // Get the switch tag.
+
+    var tag = this.peekToken(); // fail early if we get some unexpected tag.
+
+    if (!this.skipSymbol(switchStart) && !this.skipSymbol(caseStart) && !this.skipSymbol(caseDefault)) {
+      this.fail('parseSwitch: expected "switch," "case" or "default"', tag.lineno, tag.colno);
+    } // parse the switch expression
+
+
+    var expr = this.parseExpression(); // advance until a start of a case, a default case or an endswitch.
+
+    this.advanceAfterBlockEnd(switchStart);
+    this.parseUntilBlocks(caseStart, caseDefault, switchEnd); // this is the first case. it could also be an endswitch, we'll check.
+
+    var tok = this.peekToken(); // create new variables for our cases and default case.
+
+    var cases = [];
+    var defaultCase; // while we're dealing with new cases nodes...
+
+    do {
+      // skip the start symbol and get the case expression
+      this.skipSymbol(caseStart);
+      var cond = this.parseExpression();
+      this.advanceAfterBlockEnd(switchStart); // get the body of the case node and add it to the array of cases.
+
+      var body = this.parseUntilBlocks(caseStart, caseDefault, switchEnd);
+      cases.push(new nodes.Case(tok.line, tok.col, cond, body)); // get our next case
+
+      tok = this.peekToken();
+    } while (tok && tok.value === caseStart); // we either have a default case or a switch end.
+
+
+    switch (tok.value) {
+      case caseDefault:
+        this.advanceAfterBlockEnd();
+        defaultCase = this.parseUntilBlocks(switchEnd);
+        this.advanceAfterBlockEnd();
+        break;
+
+      case switchEnd:
+        this.advanceAfterBlockEnd();
+        break;
+
+      default:
+        // otherwise bail because EOF
+        this.fail('parseSwitch: expected "case," "default" or "endswitch," got EOF.');
+    } // and return the switch node.
+
+
+    return new nodes.Switch(tag.lineno, tag.colno, expr, cases, defaultCase);
+  };
+
+  _proto.parseStatement = function parseStatement() {
+    var tok = this.peekToken();
+    var node;
+
+    if (tok.type !== lexer.TOKEN_SYMBOL) {
+      this.fail('tag name expected', tok.lineno, tok.colno);
+    }
+
+    if (this.breakOnBlocks && lib.indexOf(this.breakOnBlocks, tok.value) !== -1) {
+      return null;
+    }
+
+    switch (tok.value) {
+      case 'raw':
+        return this.parseRaw();
+
+      case 'verbatim':
+        return this.parseRaw('verbatim');
+
+      case 'if':
+      case 'ifAsync':
+        return this.parseIf();
+
+      case 'for':
+      case 'asyncEach':
+      case 'asyncAll':
+        return this.parseFor();
+
+      case 'block':
+        return this.parseBlock();
+
+      case 'extends':
+        return this.parseExtends();
+
+      case 'include':
+        return this.parseInclude();
+
+      case 'set':
+        return this.parseSet();
+
+      case 'macro':
+        return this.parseMacro();
+
+      case 'call':
+        return this.parseCall();
+
+      case 'import':
+        return this.parseImport();
+
+      case 'from':
+        return this.parseFrom();
+
+      case 'filter':
+        return this.parseFilterStatement();
+
+      case 'switch':
+        return this.parseSwitch();
+
+      default:
+        if (this.extensions.length) {
+          for (var i = 0; i < this.extensions.length; i++) {
+            var ext = this.extensions[i];
+
+            if (lib.indexOf(ext.tags || [], tok.value) !== -1) {
+              return ext.parse(this, nodes, lexer);
+            }
+          }
+        }
+
+        this.fail('unknown block tag: ' + tok.value, tok.lineno, tok.colno);
+    }
+
+    return node;
+  };
+
+  _proto.parseRaw = function parseRaw(tagName) {
+    tagName = tagName || 'raw';
+    var endTagName = 'end' + tagName; // Look for upcoming raw blocks (ignore all other kinds of blocks)
+
+    var rawBlockRegex = new RegExp('([\\s\\S]*?){%\\s*(' + tagName + '|' + endTagName + ')\\s*(?=%})%}');
+    var rawLevel = 1;
+    var str = '';
+    var matches = null; // Skip opening raw token
+    // Keep this token to track line and column numbers
+
+    var begun = this.advanceAfterBlockEnd(); // Exit when there's nothing to match
+    // or when we've found the matching "endraw" block
+
+    while ((matches = this.tokens._extractRegex(rawBlockRegex)) && rawLevel > 0) {
+      var all = matches[0];
+      var pre = matches[1];
+      var blockName = matches[2]; // Adjust rawlevel
+
+      if (blockName === tagName) {
+        rawLevel += 1;
+      } else if (blockName === endTagName) {
+        rawLevel -= 1;
+      } // Add to str
+
+
+      if (rawLevel === 0) {
+        // We want to exclude the last "endraw"
+        str += pre; // Move tokenizer to beginning of endraw block
+
+        this.tokens.backN(all.length - pre.length);
+      } else {
+        str += all;
+      }
+    }
+
+    return new nodes.Output(begun.lineno, begun.colno, [new nodes.TemplateData(begun.lineno, begun.colno, str)]);
+  };
+
+  _proto.parsePostfix = function parsePostfix(node) {
+    var lookup;
+    var tok = this.peekToken();
+
+    while (tok) {
+      if (tok.type === lexer.TOKEN_LEFT_PAREN) {
+        // Function call
+        node = new nodes.FunCall(tok.lineno, tok.colno, node, this.parseSignature());
+      } else if (tok.type === lexer.TOKEN_LEFT_BRACKET) {
+        // Reference
+        lookup = this.parseAggregate();
+
+        if (lookup.children.length > 1) {
+          this.fail('invalid index');
+        }
+
+        node = new nodes.LookupVal(tok.lineno, tok.colno, node, lookup.children[0]);
+      } else if (tok.type === lexer.TOKEN_OPERATOR && tok.value === '.') {
+        // Reference
+        this.nextToken();
+        var val = this.nextToken();
+
+        if (val.type !== lexer.TOKEN_SYMBOL) {
+          this.fail('expected name as lookup value, got ' + val.value, val.lineno, val.colno);
+        } // Make a literal string because it's not a variable
+        // reference
+
+
+        lookup = new nodes.Literal(val.lineno, val.colno, val.value);
+        node = new nodes.LookupVal(tok.lineno, tok.colno, node, lookup);
+      } else {
+        break;
+      }
+
+      tok = this.peekToken();
+    }
+
+    return node;
+  };
+
+  _proto.parseExpression = function parseExpression() {
+    var node = this.parseInlineIf();
+    return node;
+  };
+
+  _proto.parseInlineIf = function parseInlineIf() {
+    var node = this.parseOr();
+
+    if (this.skipSymbol('if')) {
+      var condNode = this.parseOr();
+      var bodyNode = node;
+      node = new nodes.InlineIf(node.lineno, node.colno);
+      node.body = bodyNode;
+      node.cond = condNode;
+
+      if (this.skipSymbol('else')) {
+        node.else_ = this.parseOr();
+      } else {
+        node.else_ = null;
+      }
+    }
+
+    return node;
+  };
+
+  _proto.parseOr = function parseOr() {
+    var node = this.parseAnd();
+
+    while (this.skipSymbol('or')) {
+      var node2 = this.parseAnd();
+      node = new nodes.Or(node.lineno, node.colno, node, node2);
+    }
+
+    return node;
+  };
+
+  _proto.parseAnd = function parseAnd() {
+    var node = this.parseNot();
+
+    while (this.skipSymbol('and')) {
+      var node2 = this.parseNot();
+      node = new nodes.And(node.lineno, node.colno, node, node2);
+    }
+
+    return node;
+  };
+
+  _proto.parseNot = function parseNot() {
+    var tok = this.peekToken();
+
+    if (this.skipSymbol('not')) {
+      return new nodes.Not(tok.lineno, tok.colno, this.parseNot());
+    }
+
+    return this.parseIn();
+  };
+
+  _proto.parseIn = function parseIn() {
+    var node = this.parseIs();
+
+    while (1) {
+      // eslint-disable-line no-constant-condition
+      // check if the next token is 'not'
+      var tok = this.nextToken();
+
+      if (!tok) {
+        break;
+      }
+
+      var invert = tok.type === lexer.TOKEN_SYMBOL && tok.value === 'not'; // if it wasn't 'not', put it back
+
+      if (!invert) {
+        this.pushToken(tok);
+      }
+
+      if (this.skipSymbol('in')) {
+        var node2 = this.parseIs();
+        node = new nodes.In(node.lineno, node.colno, node, node2);
+
+        if (invert) {
+          node = new nodes.Not(node.lineno, node.colno, node);
+        }
+      } else {
+        // if we'd found a 'not' but this wasn't an 'in', put back the 'not'
+        if (invert) {
+          this.pushToken(tok);
+        }
+
+        break;
+      }
+    }
+
+    return node;
+  } // I put this right after "in" in the operator precedence stack. That can
+  // obviously be changed to be closer to Jinja.
+  ;
+
+  _proto.parseIs = function parseIs() {
+    var node = this.parseCompare(); // look for an is
+
+    if (this.skipSymbol('is')) {
+      // look for a not
+      var not = this.skipSymbol('not'); // get the next node
+
+      var node2 = this.parseCompare(); // create an Is node using the next node and the info from our Is node.
+
+      node = new nodes.Is(node.lineno, node.colno, node, node2); // if we have a Not, create a Not node from our Is node.
+
+      if (not) {
+        node = new nodes.Not(node.lineno, node.colno, node);
+      }
+    } // return the node.
+
+
+    return node;
+  };
+
+  _proto.parseCompare = function parseCompare() {
+    var compareOps = ['==', '===', '!=', '!==', '<', '>', '<=', '>='];
+    var expr = this.parseConcat();
+    var ops = [];
+
+    while (1) {
+      // eslint-disable-line no-constant-condition
+      var tok = this.nextToken();
+
+      if (!tok) {
+        break;
+      } else if (compareOps.indexOf(tok.value) !== -1) {
+        ops.push(new nodes.CompareOperand(tok.lineno, tok.colno, this.parseConcat(), tok.value));
+      } else {
+        this.pushToken(tok);
+        break;
+      }
+    }
+
+    if (ops.length) {
+      return new nodes.Compare(ops[0].lineno, ops[0].colno, expr, ops);
+    } else {
+      return expr;
+    }
+  } // finds the '~' for string concatenation
+  ;
+
+  _proto.parseConcat = function parseConcat() {
+    var node = this.parseAdd();
+
+    while (this.skipValue(lexer.TOKEN_TILDE, '~')) {
+      var node2 = this.parseAdd();
+      node = new nodes.Concat(node.lineno, node.colno, node, node2);
+    }
+
+    return node;
+  };
+
+  _proto.parseAdd = function parseAdd() {
+    var node = this.parseSub();
+
+    while (this.skipValue(lexer.TOKEN_OPERATOR, '+')) {
+      var node2 = this.parseSub();
+      node = new nodes.Add(node.lineno, node.colno, node, node2);
+    }
+
+    return node;
+  };
+
+  _proto.parseSub = function parseSub() {
+    var node = this.parseMul();
+
+    while (this.skipValue(lexer.TOKEN_OPERATOR, '-')) {
+      var node2 = this.parseMul();
+      node = new nodes.Sub(node.lineno, node.colno, node, node2);
+    }
+
+    return node;
+  };
+
+  _proto.parseMul = function parseMul() {
+    var node = this.parseDiv();
+
+    while (this.skipValue(lexer.TOKEN_OPERATOR, '*')) {
+      var node2 = this.parseDiv();
+      node = new nodes.Mul(node.lineno, node.colno, node, node2);
+    }
+
+    return node;
+  };
+
+  _proto.parseDiv = function parseDiv() {
+    var node = this.parseFloorDiv();
+
+    while (this.skipValue(lexer.TOKEN_OPERATOR, '/')) {
+      var node2 = this.parseFloorDiv();
+      node = new nodes.Div(node.lineno, node.colno, node, node2);
+    }
+
+    return node;
+  };
+
+  _proto.parseFloorDiv = function parseFloorDiv() {
+    var node = this.parseMod();
+
+    while (this.skipValue(lexer.TOKEN_OPERATOR, '//')) {
+      var node2 = this.parseMod();
+      node = new nodes.FloorDiv(node.lineno, node.colno, node, node2);
+    }
+
+    return node;
+  };
+
+  _proto.parseMod = function parseMod() {
+    var node = this.parsePow();
+
+    while (this.skipValue(lexer.TOKEN_OPERATOR, '%')) {
+      var node2 = this.parsePow();
+      node = new nodes.Mod(node.lineno, node.colno, node, node2);
+    }
+
+    return node;
+  };
+
+  _proto.parsePow = function parsePow() {
+    var node = this.parseUnary();
+
+    while (this.skipValue(lexer.TOKEN_OPERATOR, '**')) {
+      var node2 = this.parseUnary();
+      node = new nodes.Pow(node.lineno, node.colno, node, node2);
+    }
+
+    return node;
+  };
+
+  _proto.parseUnary = function parseUnary(noFilters) {
+    var tok = this.peekToken();
+    var node;
+
+    if (this.skipValue(lexer.TOKEN_OPERATOR, '-')) {
+      node = new nodes.Neg(tok.lineno, tok.colno, this.parseUnary(true));
+    } else if (this.skipValue(lexer.TOKEN_OPERATOR, '+')) {
+      node = new nodes.Pos(tok.lineno, tok.colno, this.parseUnary(true));
+    } else {
+      node = this.parsePrimary();
+    }
+
+    if (!noFilters) {
+      node = this.parseFilter(node);
+    }
+
+    return node;
+  };
+
+  _proto.parsePrimary = function parsePrimary(noPostfix) {
+    var tok = this.nextToken();
+    var val;
+    var node = null;
+
+    if (!tok) {
+      this.fail('expected expression, got end of file');
+    } else if (tok.type === lexer.TOKEN_STRING) {
+      val = tok.value;
+    } else if (tok.type === lexer.TOKEN_INT) {
+      val = parseInt(tok.value, 10);
+    } else if (tok.type === lexer.TOKEN_FLOAT) {
+      val = parseFloat(tok.value);
+    } else if (tok.type === lexer.TOKEN_BOOLEAN) {
+      if (tok.value === 'true') {
+        val = true;
+      } else if (tok.value === 'false') {
+        val = false;
+      } else {
+        this.fail('invalid boolean: ' + tok.value, tok.lineno, tok.colno);
+      }
+    } else if (tok.type === lexer.TOKEN_NONE) {
+      val = null;
+    } else if (tok.type === lexer.TOKEN_REGEX) {
+      val = new RegExp(tok.value.body, tok.value.flags);
+    }
+
+    if (val !== undefined) {
+      node = new nodes.Literal(tok.lineno, tok.colno, val);
+    } else if (tok.type === lexer.TOKEN_SYMBOL) {
+      node = new nodes.Symbol(tok.lineno, tok.colno, tok.value);
+    } else {
+      // See if it's an aggregate type, we need to push the
+      // current delimiter token back on
+      this.pushToken(tok);
+      node = this.parseAggregate();
+    }
+
+    if (!noPostfix) {
+      node = this.parsePostfix(node);
+    }
+
+    if (node) {
+      return node;
+    } else {
+      throw this.error("unexpected token: " + tok.value, tok.lineno, tok.colno);
+    }
+  };
+
+  _proto.parseFilterName = function parseFilterName() {
+    var tok = this.expect(lexer.TOKEN_SYMBOL);
+    var name = tok.value;
+
+    while (this.skipValue(lexer.TOKEN_OPERATOR, '.')) {
+      name += '.' + this.expect(lexer.TOKEN_SYMBOL).value;
+    }
+
+    return new nodes.Symbol(tok.lineno, tok.colno, name);
+  };
+
+  _proto.parseFilterArgs = function parseFilterArgs(node) {
+    if (this.peekToken().type === lexer.TOKEN_LEFT_PAREN) {
+      // Get a FunCall node and add the parameters to the
+      // filter
+      var call = this.parsePostfix(node);
+      return call.args.children;
+    }
+
+    return [];
+  };
+
+  _proto.parseFilter = function parseFilter(node) {
+    while (this.skip(lexer.TOKEN_PIPE)) {
+      var name = this.parseFilterName();
+      node = new nodes.Filter(name.lineno, name.colno, name, new nodes.NodeList(name.lineno, name.colno, [node].concat(this.parseFilterArgs(node))));
+    }
+
+    return node;
+  };
+
+  _proto.parseFilterStatement = function parseFilterStatement() {
+    var filterTok = this.peekToken();
+
+    if (!this.skipSymbol('filter')) {
+      this.fail('parseFilterStatement: expected filter');
+    }
+
+    var name = this.parseFilterName();
+    var args = this.parseFilterArgs(name);
+    this.advanceAfterBlockEnd(filterTok.value);
+    var body = new nodes.Capture(name.lineno, name.colno, this.parseUntilBlocks('endfilter'));
+    this.advanceAfterBlockEnd();
+    var node = new nodes.Filter(name.lineno, name.colno, name, new nodes.NodeList(name.lineno, name.colno, [body].concat(args)));
+    return new nodes.Output(name.lineno, name.colno, [node]);
+  };
+
+  _proto.parseAggregate = function parseAggregate() {
+    var tok = this.nextToken();
+    var node;
+
+    switch (tok.type) {
+      case lexer.TOKEN_LEFT_PAREN:
+        node = new nodes.Group(tok.lineno, tok.colno);
+        break;
+
+      case lexer.TOKEN_LEFT_BRACKET:
+        node = new nodes.Array(tok.lineno, tok.colno);
+        break;
+
+      case lexer.TOKEN_LEFT_CURLY:
+        node = new nodes.Dict(tok.lineno, tok.colno);
+        break;
+
+      default:
+        return null;
+    }
+
+    while (1) {
+      // eslint-disable-line no-constant-condition
+      var type = this.peekToken().type;
+
+      if (type === lexer.TOKEN_RIGHT_PAREN || type === lexer.TOKEN_RIGHT_BRACKET || type === lexer.TOKEN_RIGHT_CURLY) {
+        this.nextToken();
+        break;
+      }
+
+      if (node.children.length > 0) {
+        if (!this.skip(lexer.TOKEN_COMMA)) {
+          this.fail('parseAggregate: expected comma after expression', tok.lineno, tok.colno);
+        }
+      }
+
+      if (node instanceof nodes.Dict) {
+        // TODO: check for errors
+        var key = this.parsePrimary(); // We expect a key/value pair for dicts, separated by a
+        // colon
+
+        if (!this.skip(lexer.TOKEN_COLON)) {
+          this.fail('parseAggregate: expected colon after dict key', tok.lineno, tok.colno);
+        } // TODO: check for errors
+
+
+        var value = this.parseExpression();
+        node.addChild(new nodes.Pair(key.lineno, key.colno, key, value));
+      } else {
+        // TODO: check for errors
+        var expr = this.parseExpression();
+        node.addChild(expr);
+      }
+    }
+
+    return node;
+  };
+
+  _proto.parseSignature = function parseSignature(tolerant, noParens) {
+    var tok = this.peekToken();
+
+    if (!noParens && tok.type !== lexer.TOKEN_LEFT_PAREN) {
+      if (tolerant) {
+        return null;
+      } else {
+        this.fail('expected arguments', tok.lineno, tok.colno);
+      }
+    }
+
+    if (tok.type === lexer.TOKEN_LEFT_PAREN) {
+      tok = this.nextToken();
+    }
+
+    var args = new nodes.NodeList(tok.lineno, tok.colno);
+    var kwargs = new nodes.KeywordArgs(tok.lineno, tok.colno);
+    var checkComma = false;
+
+    while (1) {
+      // eslint-disable-line no-constant-condition
+      tok = this.peekToken();
+
+      if (!noParens && tok.type === lexer.TOKEN_RIGHT_PAREN) {
+        this.nextToken();
+        break;
+      } else if (noParens && tok.type === lexer.TOKEN_BLOCK_END) {
+        break;
+      }
+
+      if (checkComma && !this.skip(lexer.TOKEN_COMMA)) {
+        this.fail('parseSignature: expected comma after expression', tok.lineno, tok.colno);
+      } else {
+        var arg = this.parseExpression();
+
+        if (this.skipValue(lexer.TOKEN_OPERATOR, '=')) {
+          kwargs.addChild(new nodes.Pair(arg.lineno, arg.colno, arg, this.parseExpression()));
+        } else {
+          args.addChild(arg);
+        }
+      }
+
+      checkComma = true;
+    }
+
+    if (kwargs.children.length) {
+      args.addChild(kwargs);
+    }
+
+    return args;
+  };
+
+  _proto.parseUntilBlocks = function parseUntilBlocks() {
+    var prev = this.breakOnBlocks;
+
+    for (var _len = arguments.length, blockNames = new Array(_len), _key = 0; _key < _len; _key++) {
+      blockNames[_key] = arguments[_key];
+    }
+
+    this.breakOnBlocks = blockNames;
+    var ret = this.parse();
+    this.breakOnBlocks = prev;
+    return ret;
+  };
+
+  _proto.parseNodes = function parseNodes() {
+    var tok;
+    var buf = [];
+
+    while (tok = this.nextToken()) {
+      if (tok.type === lexer.TOKEN_DATA) {
+        var data = tok.value;
+        var nextToken = this.peekToken();
+        var nextVal = nextToken && nextToken.value; // If the last token has "-" we need to trim the
+        // leading whitespace of the data. This is marked with
+        // the `dropLeadingWhitespace` variable.
+
+        if (this.dropLeadingWhitespace) {
+          // TODO: this could be optimized (don't use regex)
+          data = data.replace(/^\s*/, '');
+          this.dropLeadingWhitespace = false;
+        } // Same for the succeeding block start token
+
+
+        if (nextToken && (nextToken.type === lexer.TOKEN_BLOCK_START && nextVal.charAt(nextVal.length - 1) === '-' || nextToken.type === lexer.TOKEN_VARIABLE_START && nextVal.charAt(this.tokens.tags.VARIABLE_START.length) === '-' || nextToken.type === lexer.TOKEN_COMMENT && nextVal.charAt(this.tokens.tags.COMMENT_START.length) === '-')) {
+          // TODO: this could be optimized (don't use regex)
+          data = data.replace(/\s*$/, '');
+        }
+
+        buf.push(new nodes.Output(tok.lineno, tok.colno, [new nodes.TemplateData(tok.lineno, tok.colno, data)]));
+      } else if (tok.type === lexer.TOKEN_BLOCK_START) {
+        this.dropLeadingWhitespace = false;
+        var n = this.parseStatement();
+
+        if (!n) {
+          break;
+        }
+
+        buf.push(n);
+      } else if (tok.type === lexer.TOKEN_VARIABLE_START) {
+        var e = this.parseExpression();
+        this.dropLeadingWhitespace = false;
+        this.advanceAfterVariableEnd();
+        buf.push(new nodes.Output(tok.lineno, tok.colno, [e]));
+      } else if (tok.type === lexer.TOKEN_COMMENT) {
+        this.dropLeadingWhitespace = tok.value.charAt(tok.value.length - this.tokens.tags.COMMENT_END.length - 1) === '-';
+      } else {
+        // Ignore comments, otherwise this should be an error
+        this.fail('Unexpected token at top-level: ' + tok.type, tok.lineno, tok.colno);
+      }
+    }
+
+    return buf;
+  };
+
+  _proto.parse = function parse() {
+    return new nodes.NodeList(0, 0, this.parseNodes());
+  };
+
+  _proto.parseAsRoot = function parseAsRoot() {
+    return new nodes.Root(0, 0, this.parseNodes());
+  };
+
+  return Parser;
+}(Obj); // var util = require('util');
+// var l = lexer.lex('{%- if x -%}\n hello {% endif %}');
+// var t;
+// while((t = l.nextToken())) {
+//     console.log(util.inspect(t));
+// }
+// var p = new Parser(lexer.lex('hello {% filter title %}' +
+//                              'Hello madam how are you' +
+//                              '{% endfilter %}'));
+// var n = p.parseAsRoot();
+// nodes.printNodes(n);
+
+
+module.exports = {
+  parse: function parse(src, extensions, opts) {
+    var p = new Parser(lexer.lex(src, opts));
+
+    if (extensions !== undefined) {
+      p.extensions = extensions;
+    }
+
+    return p.parseAsRoot();
+  },
+  Parser: Parser
+};
+
+/***/ }),
+
+/***/ 1524:
+/***/ ((module) => {
+
+"use strict";
+
+
+function precompileGlobal(templates, opts) {
+  var out = '';
+  opts = opts || {};
+
+  for (var i = 0; i < templates.length; i++) {
+    var name = JSON.stringify(templates[i].name);
+    var template = templates[i].template;
+    out += '(function() {' + '(window.nunjucksPrecompiled = window.nunjucksPrecompiled || {})' + '[' + name + '] = (function() {\n' + template + '\n})();\n';
+
+    if (opts.asFunction) {
+      out += 'return function(ctx, cb) { return nunjucks.render(' + name + ', ctx, cb); }\n';
+    }
+
+    out += '})();\n';
+  }
+
+  return out;
+}
+
+module.exports = precompileGlobal;
+
+/***/ }),
+
+/***/ 7513:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+var fs = __nccwpck_require__(7147);
+
+var path = __nccwpck_require__(1017);
+
+var _require = __nccwpck_require__(4127),
+    _prettifyError = _require._prettifyError;
+
+var compiler = __nccwpck_require__(4548);
+
+var _require2 = __nccwpck_require__(4428),
+    Environment = _require2.Environment;
+
+var precompileGlobal = __nccwpck_require__(1524);
+
+function match(filename, patterns) {
+  if (!Array.isArray(patterns)) {
+    return false;
+  }
+
+  return patterns.some(function (pattern) {
+    return filename.match(pattern);
+  });
+}
+
+function precompileString(str, opts) {
+  opts = opts || {};
+  opts.isString = true;
+  var env = opts.env || new Environment([]);
+  var wrapper = opts.wrapper || precompileGlobal;
+
+  if (!opts.name) {
+    throw new Error('the "name" option is required when compiling a string');
+  }
+
+  return wrapper([_precompile(str, opts.name, env)], opts);
+}
+
+function precompile(input, opts) {
+  // The following options are available:
+  //
+  // * name: name of the template (auto-generated when compiling a directory)
+  // * isString: input is a string, not a file path
+  // * asFunction: generate a callable function
+  // * force: keep compiling on error
+  // * env: the Environment to use (gets extensions and async filters from it)
+  // * include: which file/folders to include (folders are auto-included, files are auto-excluded)
+  // * exclude: which file/folders to exclude (folders are auto-included, files are auto-excluded)
+  // * wrapper: function(templates, opts) {...}
+  //       Customize the output format to store the compiled template.
+  //       By default, templates are stored in a global variable used by the runtime.
+  //       A custom loader will be necessary to load your custom wrapper.
+  opts = opts || {};
+  var env = opts.env || new Environment([]);
+  var wrapper = opts.wrapper || precompileGlobal;
+
+  if (opts.isString) {
+    return precompileString(input, opts);
+  }
+
+  var pathStats = fs.existsSync(input) && fs.statSync(input);
+  var precompiled = [];
+  var templates = [];
+
+  function addTemplates(dir) {
+    fs.readdirSync(dir).forEach(function (file) {
+      var filepath = path.join(dir, file);
+      var subpath = filepath.substr(path.join(input, '/').length);
+      var stat = fs.statSync(filepath);
+
+      if (stat && stat.isDirectory()) {
+        subpath += '/';
+
+        if (!match(subpath, opts.exclude)) {
+          addTemplates(filepath);
+        }
+      } else if (match(subpath, opts.include)) {
+        templates.push(filepath);
+      }
+    });
+  }
+
+  if (pathStats.isFile()) {
+    precompiled.push(_precompile(fs.readFileSync(input, 'utf-8'), opts.name || input, env));
+  } else if (pathStats.isDirectory()) {
+    addTemplates(input);
+
+    for (var i = 0; i < templates.length; i++) {
+      var name = templates[i].replace(path.join(input, '/'), '');
+
+      try {
+        precompiled.push(_precompile(fs.readFileSync(templates[i], 'utf-8'), name, env));
+      } catch (e) {
+        if (opts.force) {
+          // Don't stop generating the output if we're
+          // forcing compilation.
+          console.error(e); // eslint-disable-line no-console
+        } else {
+          throw e;
+        }
+      }
+    }
+  }
+
+  return wrapper(precompiled, opts);
+}
+
+function _precompile(str, name, env) {
+  env = env || new Environment([]);
+  var asyncFilters = env.asyncFilters;
+  var extensions = env.extensionsList;
+  var template;
+  name = name.replace(/\\/g, '/');
+
+  try {
+    template = compiler.compile(str, asyncFilters, extensions, name, env.opts);
+  } catch (err) {
+    throw _prettifyError(name, false, err);
+  }
+
+  return {
+    name: name,
+    template: template
+  };
+}
+
+module.exports = {
+  precompile: precompile,
+  precompileString: precompileString
+};
+
+/***/ }),
+
+/***/ 8957:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+var Loader = __nccwpck_require__(6981);
+
+var PrecompiledLoader = /*#__PURE__*/function (_Loader) {
+  _inheritsLoose(PrecompiledLoader, _Loader);
+
+  function PrecompiledLoader(compiledTemplates) {
+    var _this;
+
+    _this = _Loader.call(this) || this;
+    _this.precompiled = compiledTemplates || {};
+    return _this;
+  }
+
+  var _proto = PrecompiledLoader.prototype;
+
+  _proto.getSource = function getSource(name) {
+    if (this.precompiled[name]) {
+      return {
+        src: {
+          type: 'code',
+          obj: this.precompiled[name]
+        },
+        path: name
+      };
+    }
+
+    return null;
+  };
+
+  return PrecompiledLoader;
+}(Loader);
+
+module.exports = {
+  PrecompiledLoader: PrecompiledLoader
+};
+
+/***/ }),
+
+/***/ 1998:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+var lib = __nccwpck_require__(4127);
+
+var arrayFrom = Array.from;
+var supportsIterators = typeof Symbol === 'function' && Symbol.iterator && typeof arrayFrom === 'function'; // Frames keep track of scoping both at compile-time and run-time so
+// we know how to access variables. Block tags can introduce special
+// variables, for example.
+
+var Frame = /*#__PURE__*/function () {
+  function Frame(parent, isolateWrites) {
+    this.variables = Object.create(null);
+    this.parent = parent;
+    this.topLevel = false; // if this is true, writes (set) should never propagate upwards past
+    // this frame to its parent (though reads may).
+
+    this.isolateWrites = isolateWrites;
+  }
+
+  var _proto = Frame.prototype;
+
+  _proto.set = function set(name, val, resolveUp) {
+    // Allow variables with dots by automatically creating the
+    // nested structure
+    var parts = name.split('.');
+    var obj = this.variables;
+    var frame = this;
+
+    if (resolveUp) {
+      if (frame = this.resolve(parts[0], true)) {
+        frame.set(name, val);
+        return;
+      }
+    }
+
+    for (var i = 0; i < parts.length - 1; i++) {
+      var id = parts[i];
+
+      if (!obj[id]) {
+        obj[id] = {};
+      }
+
+      obj = obj[id];
+    }
+
+    obj[parts[parts.length - 1]] = val;
+  };
+
+  _proto.get = function get(name) {
+    var val = this.variables[name];
+
+    if (val !== undefined) {
+      return val;
+    }
+
+    return null;
+  };
+
+  _proto.lookup = function lookup(name) {
+    var p = this.parent;
+    var val = this.variables[name];
+
+    if (val !== undefined) {
+      return val;
+    }
+
+    return p && p.lookup(name);
+  };
+
+  _proto.resolve = function resolve(name, forWrite) {
+    var p = forWrite && this.isolateWrites ? undefined : this.parent;
+    var val = this.variables[name];
+
+    if (val !== undefined) {
+      return this;
+    }
+
+    return p && p.resolve(name);
+  };
+
+  _proto.push = function push(isolateWrites) {
+    return new Frame(this, isolateWrites);
+  };
+
+  _proto.pop = function pop() {
+    return this.parent;
+  };
+
+  return Frame;
+}();
+
+function makeMacro(argNames, kwargNames, func) {
+  return function macro() {
+    for (var _len = arguments.length, macroArgs = new Array(_len), _key = 0; _key < _len; _key++) {
+      macroArgs[_key] = arguments[_key];
+    }
+
+    var argCount = numArgs(macroArgs);
+    var args;
+    var kwargs = getKeywordArgs(macroArgs);
+
+    if (argCount > argNames.length) {
+      args = macroArgs.slice(0, argNames.length); // Positional arguments that should be passed in as
+      // keyword arguments (essentially default values)
+
+      macroArgs.slice(args.length, argCount).forEach(function (val, i) {
+        if (i < kwargNames.length) {
+          kwargs[kwargNames[i]] = val;
+        }
+      });
+      args.push(kwargs);
+    } else if (argCount < argNames.length) {
+      args = macroArgs.slice(0, argCount);
+
+      for (var i = argCount; i < argNames.length; i++) {
+        var arg = argNames[i]; // Keyword arguments that should be passed as
+        // positional arguments, i.e. the caller explicitly
+        // used the name of a positional arg
+
+        args.push(kwargs[arg]);
+        delete kwargs[arg];
+      }
+
+      args.push(kwargs);
+    } else {
+      args = macroArgs;
+    }
+
+    return func.apply(this, args);
+  };
+}
+
+function makeKeywordArgs(obj) {
+  obj.__keywords = true;
+  return obj;
+}
+
+function isKeywordArgs(obj) {
+  return obj && Object.prototype.hasOwnProperty.call(obj, '__keywords');
+}
+
+function getKeywordArgs(args) {
+  var len = args.length;
+
+  if (len) {
+    var lastArg = args[len - 1];
+
+    if (isKeywordArgs(lastArg)) {
+      return lastArg;
+    }
+  }
+
+  return {};
+}
+
+function numArgs(args) {
+  var len = args.length;
+
+  if (len === 0) {
+    return 0;
+  }
+
+  var lastArg = args[len - 1];
+
+  if (isKeywordArgs(lastArg)) {
+    return len - 1;
+  } else {
+    return len;
+  }
+} // A SafeString object indicates that the string should not be
+// autoescaped. This happens magically because autoescaping only
+// occurs on primitive string objects.
+
+
+function SafeString(val) {
+  if (typeof val !== 'string') {
+    return val;
+  }
+
+  this.val = val;
+  this.length = val.length;
+}
+
+SafeString.prototype = Object.create(String.prototype, {
+  length: {
+    writable: true,
+    configurable: true,
+    value: 0
+  }
+});
+
+SafeString.prototype.valueOf = function valueOf() {
+  return this.val;
+};
+
+SafeString.prototype.toString = function toString() {
+  return this.val;
+};
+
+function copySafeness(dest, target) {
+  if (dest instanceof SafeString) {
+    return new SafeString(target);
+  }
+
+  return target.toString();
+}
+
+function markSafe(val) {
+  var type = typeof val;
+
+  if (type === 'string') {
+    return new SafeString(val);
+  } else if (type !== 'function') {
+    return val;
+  } else {
+    return function wrapSafe(args) {
+      var ret = val.apply(this, arguments);
+
+      if (typeof ret === 'string') {
+        return new SafeString(ret);
+      }
+
+      return ret;
+    };
+  }
+}
+
+function suppressValue(val, autoescape) {
+  val = val !== undefined && val !== null ? val : '';
+
+  if (autoescape && !(val instanceof SafeString)) {
+    val = lib.escape(val.toString());
+  }
+
+  return val;
+}
+
+function ensureDefined(val, lineno, colno) {
+  if (val === null || val === undefined) {
+    throw new lib.TemplateError('attempted to output null or undefined value', lineno + 1, colno + 1);
+  }
+
+  return val;
+}
+
+function memberLookup(obj, val) {
+  if (obj === undefined || obj === null) {
+    return undefined;
+  }
+
+  if (typeof obj[val] === 'function') {
+    return function () {
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+
+      return obj[val].apply(obj, args);
+    };
+  }
+
+  return obj[val];
+}
+
+function callWrap(obj, name, context, args) {
+  if (!obj) {
+    throw new Error('Unable to call `' + name + '`, which is undefined or falsey');
+  } else if (typeof obj !== 'function') {
+    throw new Error('Unable to call `' + name + '`, which is not a function');
+  }
+
+  return obj.apply(context, args);
+}
+
+function contextOrFrameLookup(context, frame, name) {
+  var val = frame.lookup(name);
+  return val !== undefined ? val : context.lookup(name);
+}
+
+function handleError(error, lineno, colno) {
+  if (error.lineno) {
+    return error;
+  } else {
+    return new lib.TemplateError(error, lineno, colno);
+  }
+}
+
+function asyncEach(arr, dimen, iter, cb) {
+  if (lib.isArray(arr)) {
+    var len = arr.length;
+    lib.asyncIter(arr, function iterCallback(item, i, next) {
+      switch (dimen) {
+        case 1:
+          iter(item, i, len, next);
+          break;
+
+        case 2:
+          iter(item[0], item[1], i, len, next);
+          break;
+
+        case 3:
+          iter(item[0], item[1], item[2], i, len, next);
+          break;
+
+        default:
+          item.push(i, len, next);
+          iter.apply(this, item);
+      }
+    }, cb);
+  } else {
+    lib.asyncFor(arr, function iterCallback(key, val, i, len, next) {
+      iter(key, val, i, len, next);
+    }, cb);
+  }
+}
+
+function asyncAll(arr, dimen, func, cb) {
+  var finished = 0;
+  var len;
+  var outputArr;
+
+  function done(i, output) {
+    finished++;
+    outputArr[i] = output;
+
+    if (finished === len) {
+      cb(null, outputArr.join(''));
+    }
+  }
+
+  if (lib.isArray(arr)) {
+    len = arr.length;
+    outputArr = new Array(len);
+
+    if (len === 0) {
+      cb(null, '');
+    } else {
+      for (var i = 0; i < arr.length; i++) {
+        var item = arr[i];
+
+        switch (dimen) {
+          case 1:
+            func(item, i, len, done);
+            break;
+
+          case 2:
+            func(item[0], item[1], i, len, done);
+            break;
+
+          case 3:
+            func(item[0], item[1], item[2], i, len, done);
+            break;
+
+          default:
+            item.push(i, len, done);
+            func.apply(this, item);
+        }
+      }
+    }
+  } else {
+    var keys = lib.keys(arr || {});
+    len = keys.length;
+    outputArr = new Array(len);
+
+    if (len === 0) {
+      cb(null, '');
+    } else {
+      for (var _i = 0; _i < keys.length; _i++) {
+        var k = keys[_i];
+        func(k, arr[k], _i, len, done);
+      }
+    }
+  }
+}
+
+function fromIterator(arr) {
+  if (typeof arr !== 'object' || arr === null || lib.isArray(arr)) {
+    return arr;
+  } else if (supportsIterators && Symbol.iterator in arr) {
+    return arrayFrom(arr);
+  } else {
+    return arr;
+  }
+}
+
+module.exports = {
+  Frame: Frame,
+  makeMacro: makeMacro,
+  makeKeywordArgs: makeKeywordArgs,
+  numArgs: numArgs,
+  suppressValue: suppressValue,
+  ensureDefined: ensureDefined,
+  memberLookup: memberLookup,
+  contextOrFrameLookup: contextOrFrameLookup,
+  callWrap: callWrap,
+  handleError: handleError,
+  isArray: lib.isArray,
+  keys: lib.keys,
+  SafeString: SafeString,
+  copySafeness: copySafeness,
+  markSafe: markSafe,
+  asyncEach: asyncEach,
+  asyncAll: asyncAll,
+  inOperator: lib.inOperator,
+  fromIterator: fromIterator
+};
+
+/***/ }),
+
+/***/ 841:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+var SafeString = (__nccwpck_require__(1998).SafeString);
+/**
+ * Returns `true` if the object is a function, otherwise `false`.
+ * @param { any } value
+ * @returns { boolean }
+ */
+
+
+function callable(value) {
+  return typeof value === 'function';
+}
+
+exports.callable = callable;
+/**
+ * Returns `true` if the object is strictly not `undefined`.
+ * @param { any } value
+ * @returns { boolean }
+ */
+
+function defined(value) {
+  return value !== undefined;
+}
+
+exports.defined = defined;
+/**
+ * Returns `true` if the operand (one) is divisble by the test's argument
+ * (two).
+ * @param { number } one
+ * @param { number } two
+ * @returns { boolean }
+ */
+
+function divisibleby(one, two) {
+  return one % two === 0;
+}
+
+exports.divisibleby = divisibleby;
+/**
+ * Returns true if the string has been escaped (i.e., is a SafeString).
+ * @param { any } value
+ * @returns { boolean }
+ */
+
+function escaped(value) {
+  return value instanceof SafeString;
+}
+
+exports.escaped = escaped;
+/**
+ * Returns `true` if the arguments are strictly equal.
+ * @param { any } one
+ * @param { any } two
+ */
+
+function equalto(one, two) {
+  return one === two;
+}
+
+exports.equalto = equalto; // Aliases
+
+exports.eq = exports.equalto;
+exports.sameas = exports.equalto;
+/**
+ * Returns `true` if the value is evenly divisible by 2.
+ * @param { number } value
+ * @returns { boolean }
+ */
+
+function even(value) {
+  return value % 2 === 0;
+}
+
+exports.even = even;
+/**
+ * Returns `true` if the value is falsy - if I recall correctly, '', 0, false,
+ * undefined, NaN or null. I don't know if we should stick to the default JS
+ * behavior or attempt to replicate what Python believes should be falsy (i.e.,
+ * empty arrays, empty dicts, not 0...).
+ * @param { any } value
+ * @returns { boolean }
+ */
+
+function falsy(value) {
+  return !value;
+}
+
+exports.falsy = falsy;
+/**
+ * Returns `true` if the operand (one) is greater or equal to the test's
+ * argument (two).
+ * @param { number } one
+ * @param { number } two
+ * @returns { boolean }
+ */
+
+function ge(one, two) {
+  return one >= two;
+}
+
+exports.ge = ge;
+/**
+ * Returns `true` if the operand (one) is greater than the test's argument
+ * (two).
+ * @param { number } one
+ * @param { number } two
+ * @returns { boolean }
+ */
+
+function greaterthan(one, two) {
+  return one > two;
+}
+
+exports.greaterthan = greaterthan; // alias
+
+exports.gt = exports.greaterthan;
+/**
+ * Returns `true` if the operand (one) is less than or equal to the test's
+ * argument (two).
+ * @param { number } one
+ * @param { number } two
+ * @returns { boolean }
+ */
+
+function le(one, two) {
+  return one <= two;
+}
+
+exports.le = le;
+/**
+ * Returns `true` if the operand (one) is less than the test's passed argument
+ * (two).
+ * @param { number } one
+ * @param { number } two
+ * @returns { boolean }
+ */
+
+function lessthan(one, two) {
+  return one < two;
+}
+
+exports.lessthan = lessthan; // alias
+
+exports.lt = exports.lessthan;
+/**
+ * Returns `true` if the string is lowercased.
+ * @param { string } value
+ * @returns { boolean }
+ */
+
+function lower(value) {
+  return value.toLowerCase() === value;
+}
+
+exports.lower = lower;
+/**
+ * Returns `true` if the operand (one) is less than or equal to the test's
+ * argument (two).
+ * @param { number } one
+ * @param { number } two
+ * @returns { boolean }
+ */
+
+function ne(one, two) {
+  return one !== two;
+}
+
+exports.ne = ne;
+/**
+ * Returns true if the value is strictly equal to `null`.
+ * @param { any }
+ * @returns { boolean }
+ */
+
+function nullTest(value) {
+  return value === null;
+}
+
+exports["null"] = nullTest;
+/**
+ * Returns true if value is a number.
+ * @param { any }
+ * @returns { boolean }
+ */
+
+function number(value) {
+  return typeof value === 'number';
+}
+
+exports.number = number;
+/**
+ * Returns `true` if the value is *not* evenly divisible by 2.
+ * @param { number } value
+ * @returns { boolean }
+ */
+
+function odd(value) {
+  return value % 2 === 1;
+}
+
+exports.odd = odd;
+/**
+ * Returns `true` if the value is a string, `false` if not.
+ * @param { any } value
+ * @returns { boolean }
+ */
+
+function string(value) {
+  return typeof value === 'string';
+}
+
+exports.string = string;
+/**
+ * Returns `true` if the value is not in the list of things considered falsy:
+ * '', null, undefined, 0, NaN and false.
+ * @param { any } value
+ * @returns { boolean }
+ */
+
+function truthy(value) {
+  return !!value;
+}
+
+exports.truthy = truthy;
+/**
+ * Returns `true` if the value is undefined.
+ * @param { any } value
+ * @returns { boolean }
+ */
+
+function undefinedTest(value) {
+  return value === undefined;
+}
+
+exports.undefined = undefinedTest;
+/**
+ * Returns `true` if the string is uppercased.
+ * @param { string } value
+ * @returns { boolean }
+ */
+
+function upper(value) {
+  return value.toUpperCase() === value;
+}
+
+exports.upper = upper;
+/**
+ * If ES6 features are available, returns `true` if the value implements the
+ * `Symbol.iterator` method. If not, it's a string or Array.
+ *
+ * Could potentially cause issues if a browser exists that has Set and Map but
+ * not Symbol.
+ *
+ * @param { any } value
+ * @returns { boolean }
+ */
+
+function iterable(value) {
+  if (typeof Symbol !== 'undefined') {
+    return !!value[Symbol.iterator];
+  } else {
+    return Array.isArray(value) || typeof value === 'string';
+  }
+}
+
+exports.iterable = iterable;
+/**
+ * If ES6 features are available, returns `true` if the value is an object hash
+ * or an ES6 Map. Otherwise just return if it's an object hash.
+ * @param { any } value
+ * @returns { boolean }
+ */
+
+function mapping(value) {
+  // only maps and object hashes
+  var bool = value !== null && value !== undefined && typeof value === 'object' && !Array.isArray(value);
+
+  if (Set) {
+    return bool && !(value instanceof Set);
+  } else {
+    return bool;
+  }
+}
+
+exports.mapping = mapping;
+
+/***/ }),
+
+/***/ 3773:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+var nodes = __nccwpck_require__(429);
+
+var lib = __nccwpck_require__(4127);
+
+var sym = 0;
+
+function gensym() {
+  return 'hole_' + sym++;
+} // copy-on-write version of map
+
+
+function mapCOW(arr, func) {
+  var res = null;
+
+  for (var i = 0; i < arr.length; i++) {
+    var item = func(arr[i]);
+
+    if (item !== arr[i]) {
+      if (!res) {
+        res = arr.slice();
+      }
+
+      res[i] = item;
+    }
+  }
+
+  return res || arr;
+}
+
+function walk(ast, func, depthFirst) {
+  if (!(ast instanceof nodes.Node)) {
+    return ast;
+  }
+
+  if (!depthFirst) {
+    var astT = func(ast);
+
+    if (astT && astT !== ast) {
+      return astT;
+    }
+  }
+
+  if (ast instanceof nodes.NodeList) {
+    var children = mapCOW(ast.children, function (node) {
+      return walk(node, func, depthFirst);
+    });
+
+    if (children !== ast.children) {
+      ast = new nodes[ast.typename](ast.lineno, ast.colno, children);
+    }
+  } else if (ast instanceof nodes.CallExtension) {
+    var args = walk(ast.args, func, depthFirst);
+    var contentArgs = mapCOW(ast.contentArgs, function (node) {
+      return walk(node, func, depthFirst);
+    });
+
+    if (args !== ast.args || contentArgs !== ast.contentArgs) {
+      ast = new nodes[ast.typename](ast.extName, ast.prop, args, contentArgs);
+    }
+  } else {
+    var props = ast.fields.map(function (field) {
+      return ast[field];
+    });
+    var propsT = mapCOW(props, function (prop) {
+      return walk(prop, func, depthFirst);
+    });
+
+    if (propsT !== props) {
+      ast = new nodes[ast.typename](ast.lineno, ast.colno);
+      propsT.forEach(function (prop, i) {
+        ast[ast.fields[i]] = prop;
+      });
+    }
+  }
+
+  return depthFirst ? func(ast) || ast : ast;
+}
+
+function depthWalk(ast, func) {
+  return walk(ast, func, true);
+}
+
+function _liftFilters(node, asyncFilters, prop) {
+  var children = [];
+  var walked = depthWalk(prop ? node[prop] : node, function (descNode) {
+    var symbol;
+
+    if (descNode instanceof nodes.Block) {
+      return descNode;
+    } else if (descNode instanceof nodes.Filter && lib.indexOf(asyncFilters, descNode.name.value) !== -1 || descNode instanceof nodes.CallExtensionAsync) {
+      symbol = new nodes.Symbol(descNode.lineno, descNode.colno, gensym());
+      children.push(new nodes.FilterAsync(descNode.lineno, descNode.colno, descNode.name, descNode.args, symbol));
+    }
+
+    return symbol;
+  });
+
+  if (prop) {
+    node[prop] = walked;
+  } else {
+    node = walked;
+  }
+
+  if (children.length) {
+    children.push(node);
+    return new nodes.NodeList(node.lineno, node.colno, children);
+  } else {
+    return node;
+  }
+}
+
+function liftFilters(ast, asyncFilters) {
+  return depthWalk(ast, function (node) {
+    if (node instanceof nodes.Output) {
+      return _liftFilters(node, asyncFilters);
+    } else if (node instanceof nodes.Set) {
+      return _liftFilters(node, asyncFilters, 'value');
+    } else if (node instanceof nodes.For) {
+      return _liftFilters(node, asyncFilters, 'arr');
+    } else if (node instanceof nodes.If) {
+      return _liftFilters(node, asyncFilters, 'cond');
+    } else if (node instanceof nodes.CallExtension) {
+      return _liftFilters(node, asyncFilters, 'args');
+    } else {
+      return undefined;
+    }
+  });
+}
+
+function liftSuper(ast) {
+  return walk(ast, function (blockNode) {
+    if (!(blockNode instanceof nodes.Block)) {
+      return;
+    }
+
+    var hasSuper = false;
+    var symbol = gensym();
+    blockNode.body = walk(blockNode.body, function (node) {
+      // eslint-disable-line consistent-return
+      if (node instanceof nodes.FunCall && node.name.value === 'super') {
+        hasSuper = true;
+        return new nodes.Symbol(node.lineno, node.colno, symbol);
+      }
+    });
+
+    if (hasSuper) {
+      blockNode.body.children.unshift(new nodes.Super(0, 0, blockNode.name, new nodes.Symbol(0, 0, symbol)));
+    }
+  });
+}
+
+function convertStatements(ast) {
+  return depthWalk(ast, function (node) {
+    if (!(node instanceof nodes.If) && !(node instanceof nodes.For)) {
+      return undefined;
+    }
+
+    var async = false;
+    walk(node, function (child) {
+      if (child instanceof nodes.FilterAsync || child instanceof nodes.IfAsync || child instanceof nodes.AsyncEach || child instanceof nodes.AsyncAll || child instanceof nodes.CallExtensionAsync) {
+        async = true; // Stop iterating by returning the node
+
+        return child;
+      }
+
+      return undefined;
+    });
+
+    if (async) {
+      if (node instanceof nodes.If) {
+        return new nodes.IfAsync(node.lineno, node.colno, node.cond, node.body, node.else_);
+      } else if (node instanceof nodes.For && !(node instanceof nodes.AsyncAll)) {
+        return new nodes.AsyncEach(node.lineno, node.colno, node.arr, node.name, node.body, node.else_);
+      }
+    }
+
+    return undefined;
+  });
+}
+
+function cps(ast, asyncFilters) {
+  return convertStatements(liftSuper(liftFilters(ast, asyncFilters)));
+}
+
+function transform(ast, asyncFilters) {
+  return cps(ast, asyncFilters || []);
+} // var parser = require('./parser');
+// var src = 'hello {% foo %}{% endfoo %} end';
+// var ast = transform(parser.parse(src, [new FooExtension()]), ['bar']);
+// nodes.printNodes(ast);
+
+
+module.exports = {
+  transform: transform
+};
+
+/***/ }),
+
+/***/ 1223:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+var wrappy = __nccwpck_require__(2940)
+module.exports = wrappy(once)
+module.exports.strict = wrappy(onceStrict)
+
+once.proto = once(function () {
+  Object.defineProperty(Function.prototype, 'once', {
+    value: function () {
+      return once(this)
+    },
+    configurable: true
+  })
+
+  Object.defineProperty(Function.prototype, 'onceStrict', {
+    value: function () {
+      return onceStrict(this)
+    },
+    configurable: true
+  })
+})
+
+function once (fn) {
+  var f = function () {
+    if (f.called) return f.value
+    f.called = true
+    return f.value = fn.apply(this, arguments)
+  }
+  f.called = false
+  return f
+}
+
+function onceStrict (fn) {
+  var f = function () {
+    if (f.called)
+      throw new Error(f.onceError)
+    f.called = true
+    return f.value = fn.apply(this, arguments)
+  }
+  var name = fn.name || 'Function wrapped with `once`'
+  f.onceError = name + " shouldn't be called more than once"
+  f.called = false
+  return f
+}
+
+
+/***/ }),
+
+/***/ 4256:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+var punycode = __nccwpck_require__(5477);
+var mappingTable = __nccwpck_require__(2020);
+
+var PROCESSING_OPTIONS = {
+  TRANSITIONAL: 0,
+  NONTRANSITIONAL: 1
+};
+
+function normalize(str) { // fix bug in v8
+  return str.split('\u0000').map(function (s) { return s.normalize('NFC'); }).join('\u0000');
+}
+
+function findStatus(val) {
+  var start = 0;
+  var end = mappingTable.length - 1;
+
+  while (start <= end) {
+    var mid = Math.floor((start + end) / 2);
+
+    var target = mappingTable[mid];
+    if (target[0][0] <= val && target[0][1] >= val) {
+      return target;
+    } else if (target[0][0] > val) {
+      end = mid - 1;
+    } else {
+      start = mid + 1;
+    }
+  }
+
+  return null;
+}
+
+var regexAstralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+
+function countSymbols(string) {
+  return string
+    // replace every surrogate pair with a BMP symbol
+    .replace(regexAstralSymbols, '_')
+    // then get the length
+    .length;
+}
+
+function mapChars(domain_name, useSTD3, processing_option) {
+  var hasError = false;
+  var processed = "";
+
+  var len = countSymbols(domain_name);
+  for (var i = 0; i < len; ++i) {
+    var codePoint = domain_name.codePointAt(i);
+    var status = findStatus(codePoint);
+
+    switch (status[1]) {
+      case "disallowed":
+        hasError = true;
+        processed += String.fromCodePoint(codePoint);
+        break;
+      case "ignored":
+        break;
+      case "mapped":
+        processed += String.fromCodePoint.apply(String, status[2]);
+        break;
+      case "deviation":
+        if (processing_option === PROCESSING_OPTIONS.TRANSITIONAL) {
+          processed += String.fromCodePoint.apply(String, status[2]);
+        } else {
+          processed += String.fromCodePoint(codePoint);
+        }
+        break;
+      case "valid":
+        processed += String.fromCodePoint(codePoint);
+        break;
+      case "disallowed_STD3_mapped":
+        if (useSTD3) {
+          hasError = true;
+          processed += String.fromCodePoint(codePoint);
+        } else {
+          processed += String.fromCodePoint.apply(String, status[2]);
+        }
+        break;
+      case "disallowed_STD3_valid":
+        if (useSTD3) {
+          hasError = true;
+        }
+
+        processed += String.fromCodePoint(codePoint);
+        break;
+    }
+  }
+
+  return {
+    string: processed,
+    error: hasError
+  };
+}
+
+var combiningMarksRegex = /[\u0300-\u036F\u0483-\u0489\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u08E4-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A70\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B62\u0B63\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0C00-\u0C03\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0D01-\u0D03\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D82\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EB9\u0EBB\u0EBC\u0EC8-\u0ECD\u0F18\u0F19\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F\u109A-\u109D\u135D-\u135F\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u180B-\u180D\u18A9\u1920-\u192B\u1930-\u193B\u19B0-\u19C0\u19C8\u19C9\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F\u1AB0-\u1ABE\u1B00-\u1B04\u1B34-\u1B44\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BE6-\u1BF3\u1C24-\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF2-\u1CF4\u1CF8\u1CF9\u1DC0-\u1DF5\u1DFC-\u1DFF\u20D0-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA66F-\uA672\uA674-\uA67D\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA880\uA881\uA8B4-\uA8C4\uA8E0-\uA8F1\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9E5\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2D]|\uD800[\uDDFD\uDEE0\uDF76-\uDF7A]|\uD802[\uDE01-\uDE03\uDE05\uDE06\uDE0C-\uDE0F\uDE38-\uDE3A\uDE3F\uDEE5\uDEE6]|\uD804[\uDC00-\uDC02\uDC38-\uDC46\uDC7F-\uDC82\uDCB0-\uDCBA\uDD00-\uDD02\uDD27-\uDD34\uDD73\uDD80-\uDD82\uDDB3-\uDDC0\uDE2C-\uDE37\uDEDF-\uDEEA\uDF01-\uDF03\uDF3C\uDF3E-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF57\uDF62\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDCB0-\uDCC3\uDDAF-\uDDB5\uDDB8-\uDDC0\uDE30-\uDE40\uDEAB-\uDEB7]|\uD81A[\uDEF0-\uDEF4\uDF30-\uDF36]|\uD81B[\uDF51-\uDF7E\uDF8F-\uDF92]|\uD82F[\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD83A[\uDCD0-\uDCD6]|\uDB40[\uDD00-\uDDEF]/;
+
+function validateLabel(label, processing_option) {
+  if (label.substr(0, 4) === "xn--") {
+    label = punycode.toUnicode(label);
+    processing_option = PROCESSING_OPTIONS.NONTRANSITIONAL;
+  }
+
+  var error = false;
+
+  if (normalize(label) !== label ||
+      (label[3] === "-" && label[4] === "-") ||
+      label[0] === "-" || label[label.length - 1] === "-" ||
+      label.indexOf(".") !== -1 ||
+      label.search(combiningMarksRegex) === 0) {
+    error = true;
+  }
+
+  var len = countSymbols(label);
+  for (var i = 0; i < len; ++i) {
+    var status = findStatus(label.codePointAt(i));
+    if ((processing === PROCESSING_OPTIONS.TRANSITIONAL && status[1] !== "valid") ||
+        (processing === PROCESSING_OPTIONS.NONTRANSITIONAL &&
+         status[1] !== "valid" && status[1] !== "deviation")) {
+      error = true;
+      break;
+    }
+  }
+
+  return {
+    label: label,
+    error: error
+  };
+}
+
+function processing(domain_name, useSTD3, processing_option) {
+  var result = mapChars(domain_name, useSTD3, processing_option);
+  result.string = normalize(result.string);
+
+  var labels = result.string.split(".");
+  for (var i = 0; i < labels.length; ++i) {
+    try {
+      var validation = validateLabel(labels[i]);
+      labels[i] = validation.label;
+      result.error = result.error || validation.error;
+    } catch(e) {
+      result.error = true;
+    }
+  }
+
+  return {
+    string: labels.join("."),
+    error: result.error
+  };
+}
+
+module.exports.toASCII = function(domain_name, useSTD3, processing_option, verifyDnsLength) {
+  var result = processing(domain_name, useSTD3, processing_option);
+  var labels = result.string.split(".");
+  labels = labels.map(function(l) {
+    try {
+      return punycode.toASCII(l);
+    } catch(e) {
+      result.error = true;
+      return l;
+    }
+  });
+
+  if (verifyDnsLength) {
+    var total = labels.slice(0, labels.length - 1).join(".").length;
+    if (total.length > 253 || total.length === 0) {
+      result.error = true;
+    }
+
+    for (var i=0; i < labels.length; ++i) {
+      if (labels.length > 63 || labels.length === 0) {
+        result.error = true;
+        break;
+      }
+    }
+  }
+
+  if (result.error) return null;
+  return labels.join(".");
+};
+
+module.exports.toUnicode = function(domain_name, useSTD3) {
+  var result = processing(domain_name, useSTD3, PROCESSING_OPTIONS.NONTRANSITIONAL);
+
+  return {
+    domain: result.string,
+    error: result.error
+  };
+};
+
+module.exports.PROCESSING_OPTIONS = PROCESSING_OPTIONS;
+
+
+/***/ }),
+
+/***/ 4294:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+module.exports = __nccwpck_require__(4219);
+
+
+/***/ }),
+
+/***/ 4219:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+var net = __nccwpck_require__(1808);
+var tls = __nccwpck_require__(4404);
+var http = __nccwpck_require__(3685);
+var https = __nccwpck_require__(5687);
+var events = __nccwpck_require__(2361);
+var assert = __nccwpck_require__(9491);
+var util = __nccwpck_require__(3837);
+
+
+exports.httpOverHttp = httpOverHttp;
+exports.httpsOverHttp = httpsOverHttp;
+exports.httpOverHttps = httpOverHttps;
+exports.httpsOverHttps = httpsOverHttps;
+
+
+function httpOverHttp(options) {
+  var agent = new TunnelingAgent(options);
+  agent.request = http.request;
+  return agent;
+}
+
+function httpsOverHttp(options) {
+  var agent = new TunnelingAgent(options);
+  agent.request = http.request;
+  agent.createSocket = createSecureSocket;
+  agent.defaultPort = 443;
+  return agent;
+}
+
+function httpOverHttps(options) {
+  var agent = new TunnelingAgent(options);
+  agent.request = https.request;
+  return agent;
+}
+
+function httpsOverHttps(options) {
+  var agent = new TunnelingAgent(options);
+  agent.request = https.request;
+  agent.createSocket = createSecureSocket;
+  agent.defaultPort = 443;
+  return agent;
+}
+
+
+function TunnelingAgent(options) {
+  var self = this;
+  self.options = options || {};
+  self.proxyOptions = self.options.proxy || {};
+  self.maxSockets = self.options.maxSockets || http.Agent.defaultMaxSockets;
+  self.requests = [];
+  self.sockets = [];
+
+  self.on('free', function onFree(socket, host, port, localAddress) {
+    var options = toOptions(host, port, localAddress);
+    for (var i = 0, len = self.requests.length; i < len; ++i) {
+      var pending = self.requests[i];
+      if (pending.host === options.host && pending.port === options.port) {
+        // Detect the request to connect same origin server,
+        // reuse the connection.
+        self.requests.splice(i, 1);
+        pending.request.onSocket(socket);
+        return;
+      }
+    }
+    socket.destroy();
+    self.removeSocket(socket);
+  });
+}
+util.inherits(TunnelingAgent, events.EventEmitter);
+
+TunnelingAgent.prototype.addRequest = function addRequest(req, host, port, localAddress) {
+  var self = this;
+  var options = mergeOptions({request: req}, self.options, toOptions(host, port, localAddress));
+
+  if (self.sockets.length >= this.maxSockets) {
+    // We are over limit so we'll add it to the queue.
+    self.requests.push(options);
+    return;
+  }
+
+  // If we are under maxSockets create a new one.
+  self.createSocket(options, function(socket) {
+    socket.on('free', onFree);
+    socket.on('close', onCloseOrRemove);
+    socket.on('agentRemove', onCloseOrRemove);
+    req.onSocket(socket);
+
+    function onFree() {
+      self.emit('free', socket, options);
+    }
+
+    function onCloseOrRemove(err) {
+      self.removeSocket(socket);
+      socket.removeListener('free', onFree);
+      socket.removeListener('close', onCloseOrRemove);
+      socket.removeListener('agentRemove', onCloseOrRemove);
+    }
+  });
+};
+
+TunnelingAgent.prototype.createSocket = function createSocket(options, cb) {
+  var self = this;
+  var placeholder = {};
+  self.sockets.push(placeholder);
+
+  var connectOptions = mergeOptions({}, self.proxyOptions, {
+    method: 'CONNECT',
+    path: options.host + ':' + options.port,
+    agent: false,
+    headers: {
+      host: options.host + ':' + options.port
+    }
+  });
+  if (options.localAddress) {
+    connectOptions.localAddress = options.localAddress;
+  }
+  if (connectOptions.proxyAuth) {
+    connectOptions.headers = connectOptions.headers || {};
+    connectOptions.headers['Proxy-Authorization'] = 'Basic ' +
+        new Buffer(connectOptions.proxyAuth).toString('base64');
+  }
+
+  debug('making CONNECT request');
+  var connectReq = self.request(connectOptions);
+  connectReq.useChunkedEncodingByDefault = false; // for v0.6
+  connectReq.once('response', onResponse); // for v0.6
+  connectReq.once('upgrade', onUpgrade);   // for v0.6
+  connectReq.once('connect', onConnect);   // for v0.7 or later
+  connectReq.once('error', onError);
+  connectReq.end();
+
+  function onResponse(res) {
+    // Very hacky. This is necessary to avoid http-parser leaks.
+    res.upgrade = true;
+  }
+
+  function onUpgrade(res, socket, head) {
+    // Hacky.
+    process.nextTick(function() {
+      onConnect(res, socket, head);
+    });
+  }
+
+  function onConnect(res, socket, head) {
+    connectReq.removeAllListeners();
+    socket.removeAllListeners();
+
+    if (res.statusCode !== 200) {
+      debug('tunneling socket could not be established, statusCode=%d',
+        res.statusCode);
+      socket.destroy();
+      var error = new Error('tunneling socket could not be established, ' +
+        'statusCode=' + res.statusCode);
+      error.code = 'ECONNRESET';
+      options.request.emit('error', error);
+      self.removeSocket(placeholder);
+      return;
+    }
+    if (head.length > 0) {
+      debug('got illegal response body from proxy');
+      socket.destroy();
+      var error = new Error('got illegal response body from proxy');
+      error.code = 'ECONNRESET';
+      options.request.emit('error', error);
+      self.removeSocket(placeholder);
+      return;
+    }
+    debug('tunneling connection has established');
+    self.sockets[self.sockets.indexOf(placeholder)] = socket;
+    return cb(socket);
+  }
+
+  function onError(cause) {
+    connectReq.removeAllListeners();
+
+    debug('tunneling socket could not be established, cause=%s\n',
+          cause.message, cause.stack);
+    var error = new Error('tunneling socket could not be established, ' +
+                          'cause=' + cause.message);
+    error.code = 'ECONNRESET';
+    options.request.emit('error', error);
+    self.removeSocket(placeholder);
+  }
+};
+
+TunnelingAgent.prototype.removeSocket = function removeSocket(socket) {
+  var pos = this.sockets.indexOf(socket)
+  if (pos === -1) {
+    return;
+  }
+  this.sockets.splice(pos, 1);
+
+  var pending = this.requests.shift();
+  if (pending) {
+    // If we have pending requests and a socket gets closed a new one
+    // needs to be created to take over in the pool for the one that closed.
+    this.createSocket(pending, function(socket) {
+      pending.request.onSocket(socket);
+    });
+  }
+};
+
+function createSecureSocket(options, cb) {
+  var self = this;
+  TunnelingAgent.prototype.createSocket.call(self, options, function(socket) {
+    var hostHeader = options.request.getHeader('host');
+    var tlsOptions = mergeOptions({}, self.options, {
+      socket: socket,
+      servername: hostHeader ? hostHeader.replace(/:.*$/, '') : options.host
+    });
+
+    // 0 is dummy port for v0.6
+    var secureSocket = tls.connect(0, tlsOptions);
+    self.sockets[self.sockets.indexOf(socket)] = secureSocket;
+    cb(secureSocket);
+  });
+}
+
+
+function toOptions(host, port, localAddress) {
+  if (typeof host === 'string') { // since v0.10
+    return {
+      host: host,
+      port: port,
+      localAddress: localAddress
+    };
+  }
+  return host; // for v0.11 or later
+}
+
+function mergeOptions(target) {
+  for (var i = 1, len = arguments.length; i < len; ++i) {
+    var overrides = arguments[i];
+    if (typeof overrides === 'object') {
+      var keys = Object.keys(overrides);
+      for (var j = 0, keyLen = keys.length; j < keyLen; ++j) {
+        var k = keys[j];
+        if (overrides[k] !== undefined) {
+          target[k] = overrides[k];
+        }
+      }
+    }
+  }
+  return target;
+}
+
+
+var debug;
+if (process.env.NODE_DEBUG && /\btunnel\b/.test(process.env.NODE_DEBUG)) {
+  debug = function() {
+    var args = Array.prototype.slice.call(arguments);
+    if (typeof args[0] === 'string') {
+      args[0] = 'TUNNEL: ' + args[0];
+    } else {
+      args.unshift('TUNNEL:');
+    }
+    console.error.apply(console, args);
+  }
+} else {
+  debug = function() {};
+}
+exports.debug = debug; // for test
+
+
+/***/ }),
+
+/***/ 5030:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+function getUserAgent() {
+  if (typeof navigator === "object" && "userAgent" in navigator) {
+    return navigator.userAgent;
+  }
+
+  if (typeof process === "object" && "version" in process) {
+    return `Node.js/${process.version.substr(1)} (${process.platform}; ${process.arch})`;
+  }
+
+  return "<environment undetectable>";
+}
+
+exports.getUserAgent = getUserAgent;
+//# sourceMappingURL=index.js.map
+
+
+/***/ }),
+
+/***/ 1463:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+
+exports.fromCallback = function (fn) {
+  return Object.defineProperty(function (...args) {
+    if (typeof args[args.length - 1] === 'function') fn.apply(this, args)
+    else {
+      return new Promise((resolve, reject) => {
+        fn.call(
+          this,
+          ...args,
+          (err, res) => (err != null) ? reject(err) : resolve(res)
+        )
+      })
+    }
+  }, 'name', { value: fn.name })
+}
+
+exports.fromPromise = function (fn) {
+  return Object.defineProperty(function (...args) {
+    const cb = args[args.length - 1]
+    if (typeof cb !== 'function') return fn.apply(this, args)
+    else fn.apply(this, args.slice(0, -1)).then(r => cb(null, r), cb)
+  }, 'name', { value: fn.name })
+}
+
+
+/***/ }),
+
+/***/ 5840:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+Object.defineProperty(exports, "v1", ({
+  enumerable: true,
+  get: function () {
+    return _v.default;
+  }
+}));
+Object.defineProperty(exports, "v3", ({
+  enumerable: true,
+  get: function () {
+    return _v2.default;
+  }
+}));
+Object.defineProperty(exports, "v4", ({
+  enumerable: true,
+  get: function () {
+    return _v3.default;
+  }
+}));
+Object.defineProperty(exports, "v5", ({
+  enumerable: true,
+  get: function () {
+    return _v4.default;
+  }
+}));
+Object.defineProperty(exports, "NIL", ({
+  enumerable: true,
+  get: function () {
+    return _nil.default;
+  }
+}));
+Object.defineProperty(exports, "version", ({
+  enumerable: true,
+  get: function () {
+    return _version.default;
+  }
+}));
+Object.defineProperty(exports, "validate", ({
+  enumerable: true,
+  get: function () {
+    return _validate.default;
+  }
+}));
+Object.defineProperty(exports, "stringify", ({
+  enumerable: true,
+  get: function () {
+    return _stringify.default;
+  }
+}));
+Object.defineProperty(exports, "parse", ({
+  enumerable: true,
+  get: function () {
+    return _parse.default;
+  }
+}));
+
+var _v = _interopRequireDefault(__nccwpck_require__(8628));
+
+var _v2 = _interopRequireDefault(__nccwpck_require__(6409));
+
+var _v3 = _interopRequireDefault(__nccwpck_require__(5122));
+
+var _v4 = _interopRequireDefault(__nccwpck_require__(9120));
+
+var _nil = _interopRequireDefault(__nccwpck_require__(5332));
+
+var _version = _interopRequireDefault(__nccwpck_require__(1595));
+
+var _validate = _interopRequireDefault(__nccwpck_require__(6900));
+
+var _stringify = _interopRequireDefault(__nccwpck_require__(8950));
+
+var _parse = _interopRequireDefault(__nccwpck_require__(2746));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/***/ }),
+
+/***/ 4569:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports["default"] = void 0;
+
+var _crypto = _interopRequireDefault(__nccwpck_require__(6113));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function md5(bytes) {
+  if (Array.isArray(bytes)) {
+    bytes = Buffer.from(bytes);
+  } else if (typeof bytes === 'string') {
+    bytes = Buffer.from(bytes, 'utf8');
+  }
+
+  return _crypto.default.createHash('md5').update(bytes).digest();
+}
+
+var _default = md5;
+exports["default"] = _default;
+
+/***/ }),
+
+/***/ 5332:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports["default"] = void 0;
+var _default = '00000000-0000-0000-0000-000000000000';
+exports["default"] = _default;
+
+/***/ }),
+
+/***/ 2746:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports["default"] = void 0;
+
+var _validate = _interopRequireDefault(__nccwpck_require__(6900));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function parse(uuid) {
+  if (!(0, _validate.default)(uuid)) {
+    throw TypeError('Invalid UUID');
+  }
+
+  let v;
+  const arr = new Uint8Array(16); // Parse ########-....-....-....-............
+
+  arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24;
+  arr[1] = v >>> 16 & 0xff;
+  arr[2] = v >>> 8 & 0xff;
+  arr[3] = v & 0xff; // Parse ........-####-....-....-............
+
+  arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8;
+  arr[5] = v & 0xff; // Parse ........-....-####-....-............
+
+  arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8;
+  arr[7] = v & 0xff; // Parse ........-....-....-####-............
 
-        processed += String.fromCodePoint(codePoint);
-        break;
-    }
-  }
+  arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8;
+  arr[9] = v & 0xff; // Parse ........-....-....-....-############
+  // (Use "/" to avoid 32-bit truncation when bit-shifting high-order bytes)
 
-  return {
-    string: processed,
-    error: hasError
-  };
+  arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000 & 0xff;
+  arr[11] = v / 0x100000000 & 0xff;
+  arr[12] = v >>> 24 & 0xff;
+  arr[13] = v >>> 16 & 0xff;
+  arr[14] = v >>> 8 & 0xff;
+  arr[15] = v & 0xff;
+  return arr;
 }
 
-var combiningMarksRegex = /[\u0300-\u036F\u0483-\u0489\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u08E4-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A70\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B62\u0B63\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0C00-\u0C03\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0D01-\u0D03\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D82\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EB9\u0EBB\u0EBC\u0EC8-\u0ECD\u0F18\u0F19\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F\u109A-\u109D\u135D-\u135F\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u180B-\u180D\u18A9\u1920-\u192B\u1930-\u193B\u19B0-\u19C0\u19C8\u19C9\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F\u1AB0-\u1ABE\u1B00-\u1B04\u1B34-\u1B44\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BE6-\u1BF3\u1C24-\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF2-\u1CF4\u1CF8\u1CF9\u1DC0-\u1DF5\u1DFC-\u1DFF\u20D0-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA66F-\uA672\uA674-\uA67D\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA880\uA881\uA8B4-\uA8C4\uA8E0-\uA8F1\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9E5\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2D]|\uD800[\uDDFD\uDEE0\uDF76-\uDF7A]|\uD802[\uDE01-\uDE03\uDE05\uDE06\uDE0C-\uDE0F\uDE38-\uDE3A\uDE3F\uDEE5\uDEE6]|\uD804[\uDC00-\uDC02\uDC38-\uDC46\uDC7F-\uDC82\uDCB0-\uDCBA\uDD00-\uDD02\uDD27-\uDD34\uDD73\uDD80-\uDD82\uDDB3-\uDDC0\uDE2C-\uDE37\uDEDF-\uDEEA\uDF01-\uDF03\uDF3C\uDF3E-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF57\uDF62\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDCB0-\uDCC3\uDDAF-\uDDB5\uDDB8-\uDDC0\uDE30-\uDE40\uDEAB-\uDEB7]|\uD81A[\uDEF0-\uDEF4\uDF30-\uDF36]|\uD81B[\uDF51-\uDF7E\uDF8F-\uDF92]|\uD82F[\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD83A[\uDCD0-\uDCD6]|\uDB40[\uDD00-\uDDEF]/;
+var _default = parse;
+exports["default"] = _default;
 
-function validateLabel(label, processing_option) {
-  if (label.substr(0, 4) === "xn--") {
-    label = punycode.toUnicode(label);
-    processing_option = PROCESSING_OPTIONS.NONTRANSITIONAL;
-  }
+/***/ }),
 
-  var error = false;
+/***/ 814:
+/***/ ((__unused_webpack_module, exports) => {
 
-  if (normalize(label) !== label ||
-      (label[3] === "-" && label[4] === "-") ||
-      label[0] === "-" || label[label.length - 1] === "-" ||
-      label.indexOf(".") !== -1 ||
-      label.search(combiningMarksRegex) === 0) {
-    error = true;
-  }
+"use strict";
 
-  var len = countSymbols(label);
-  for (var i = 0; i < len; ++i) {
-    var status = findStatus(label.codePointAt(i));
-    if ((processing === PROCESSING_OPTIONS.TRANSITIONAL && status[1] !== "valid") ||
-        (processing === PROCESSING_OPTIONS.NONTRANSITIONAL &&
-         status[1] !== "valid" && status[1] !== "deviation")) {
-      error = true;
-      break;
-    }
-  }
 
-  return {
-    label: label,
-    error: error
-  };
-}
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports["default"] = void 0;
+var _default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
+exports["default"] = _default;
 
-function processing(domain_name, useSTD3, processing_option) {
-  var result = mapChars(domain_name, useSTD3, processing_option);
-  result.string = normalize(result.string);
+/***/ }),
 
-  var labels = result.string.split(".");
-  for (var i = 0; i < labels.length; ++i) {
-    try {
-      var validation = validateLabel(labels[i]);
-      labels[i] = validation.label;
-      result.error = result.error || validation.error;
-    } catch(e) {
-      result.error = true;
-    }
-  }
+/***/ 807:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
 
-  return {
-    string: labels.join("."),
-    error: result.error
-  };
-}
+"use strict";
 
-module.exports.toASCII = function(domain_name, useSTD3, processing_option, verifyDnsLength) {
-  var result = processing(domain_name, useSTD3, processing_option);
-  var labels = result.string.split(".");
-  labels = labels.map(function(l) {
-    try {
-      return punycode.toASCII(l);
-    } catch(e) {
-      result.error = true;
-      return l;
-    }
-  });
 
-  if (verifyDnsLength) {
-    var total = labels.slice(0, labels.length - 1).join(".").length;
-    if (total.length > 253 || total.length === 0) {
-      result.error = true;
-    }
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports["default"] = rng;
 
-    for (var i=0; i < labels.length; ++i) {
-      if (labels.length > 63 || labels.length === 0) {
-        result.error = true;
-        break;
-      }
-    }
-  }
+var _crypto = _interopRequireDefault(__nccwpck_require__(6113));
 
-  if (result.error) return null;
-  return labels.join(".");
-};
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-module.exports.toUnicode = function(domain_name, useSTD3) {
-  var result = processing(domain_name, useSTD3, PROCESSING_OPTIONS.NONTRANSITIONAL);
+const rnds8Pool = new Uint8Array(256); // # of random values to pre-allocate
 
-  return {
-    domain: result.string,
-    error: result.error
-  };
-};
+let poolPtr = rnds8Pool.length;
 
-module.exports.PROCESSING_OPTIONS = PROCESSING_OPTIONS;
+function rng() {
+  if (poolPtr > rnds8Pool.length - 16) {
+    _crypto.default.randomFillSync(rnds8Pool);
+
+    poolPtr = 0;
+  }
 
+  return rnds8Pool.slice(poolPtr, poolPtr += 16);
+}
 
 /***/ }),
 
-/***/ 4294:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+/***/ 5274:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
 
-module.exports = __nccwpck_require__(4219);
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports["default"] = void 0;
+
+var _crypto = _interopRequireDefault(__nccwpck_require__(6113));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function sha1(bytes) {
+  if (Array.isArray(bytes)) {
+    bytes = Buffer.from(bytes);
+  } else if (typeof bytes === 'string') {
+    bytes = Buffer.from(bytes, 'utf8');
+  }
 
+  return _crypto.default.createHash('sha1').update(bytes).digest();
+}
+
+var _default = sha1;
+exports["default"] = _default;
 
 /***/ }),
 
-/***/ 4219:
+/***/ 8950:
 /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
 
 "use strict";
 
 
-var net = __nccwpck_require__(1808);
-var tls = __nccwpck_require__(4404);
-var http = __nccwpck_require__(3685);
-var https = __nccwpck_require__(5687);
-var events = __nccwpck_require__(2361);
-var assert = __nccwpck_require__(9491);
-var util = __nccwpck_require__(3837);
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports["default"] = void 0;
 
+var _validate = _interopRequireDefault(__nccwpck_require__(6900));
 
-exports.httpOverHttp = httpOverHttp;
-exports.httpsOverHttp = httpsOverHttp;
-exports.httpOverHttps = httpOverHttps;
-exports.httpsOverHttps = httpsOverHttps;
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+/**
+ * Convert array of 16 byte values to UUID string format of the form:
+ * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+ */
+const byteToHex = [];
 
-function httpOverHttp(options) {
-  var agent = new TunnelingAgent(options);
-  agent.request = http.request;
-  return agent;
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 0x100).toString(16).substr(1));
 }
 
-function httpsOverHttp(options) {
-  var agent = new TunnelingAgent(options);
-  agent.request = http.request;
-  agent.createSocket = createSecureSocket;
-  agent.defaultPort = 443;
-  return agent;
-}
+function stringify(arr, offset = 0) {
+  // Note: Be careful editing this code!  It's been tuned for performance
+  // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
+  const uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID.  If this throws, it's likely due to one
+  // of the following:
+  // - One or more input array values don't map to a hex octet (leading to
+  // "undefined" in the uuid)
+  // - Invalid input values for the RFC `version` or `variant` fields
 
-function httpOverHttps(options) {
-  var agent = new TunnelingAgent(options);
-  agent.request = https.request;
-  return agent;
-}
+  if (!(0, _validate.default)(uuid)) {
+    throw TypeError('Stringified UUID is invalid');
+  }
 
-function httpsOverHttps(options) {
-  var agent = new TunnelingAgent(options);
-  agent.request = https.request;
-  agent.createSocket = createSecureSocket;
-  agent.defaultPort = 443;
-  return agent;
+  return uuid;
 }
 
+var _default = stringify;
+exports["default"] = _default;
 
-function TunnelingAgent(options) {
-  var self = this;
-  self.options = options || {};
-  self.proxyOptions = self.options.proxy || {};
-  self.maxSockets = self.options.maxSockets || http.Agent.defaultMaxSockets;
-  self.requests = [];
-  self.sockets = [];
+/***/ }),
 
-  self.on('free', function onFree(socket, host, port, localAddress) {
-    var options = toOptions(host, port, localAddress);
-    for (var i = 0, len = self.requests.length; i < len; ++i) {
-      var pending = self.requests[i];
-      if (pending.host === options.host && pending.port === options.port) {
-        // Detect the request to connect same origin server,
-        // reuse the connection.
-        self.requests.splice(i, 1);
-        pending.request.onSocket(socket);
-        return;
-      }
-    }
-    socket.destroy();
-    self.removeSocket(socket);
-  });
-}
-util.inherits(TunnelingAgent, events.EventEmitter);
+/***/ 8628:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
 
-TunnelingAgent.prototype.addRequest = function addRequest(req, host, port, localAddress) {
-  var self = this;
-  var options = mergeOptions({request: req}, self.options, toOptions(host, port, localAddress));
+"use strict";
 
-  if (self.sockets.length >= this.maxSockets) {
-    // We are over limit so we'll add it to the queue.
-    self.requests.push(options);
-    return;
-  }
 
-  // If we are under maxSockets create a new one.
-  self.createSocket(options, function(socket) {
-    socket.on('free', onFree);
-    socket.on('close', onCloseOrRemove);
-    socket.on('agentRemove', onCloseOrRemove);
-    req.onSocket(socket);
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports["default"] = void 0;
 
-    function onFree() {
-      self.emit('free', socket, options);
+var _rng = _interopRequireDefault(__nccwpck_require__(807));
+
+var _stringify = _interopRequireDefault(__nccwpck_require__(8950));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// **`v1()` - Generate time-based UUID**
+//
+// Inspired by https://github.com/LiosK/UUID.js
+// and http://docs.python.org/library/uuid.html
+let _nodeId;
+
+let _clockseq; // Previous uuid creation time
+
+
+let _lastMSecs = 0;
+let _lastNSecs = 0; // See https://github.com/uuidjs/uuid for API details
+
+function v1(options, buf, offset) {
+  let i = buf && offset || 0;
+  const b = buf || new Array(16);
+  options = options || {};
+  let node = options.node || _nodeId;
+  let clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq; // node and clockseq need to be initialized to random values if they're not
+  // specified.  We do this lazily to minimize issues related to insufficient
+  // system entropy.  See #189
+
+  if (node == null || clockseq == null) {
+    const seedBytes = options.random || (options.rng || _rng.default)();
+
+    if (node == null) {
+      // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)
+      node = _nodeId = [seedBytes[0] | 0x01, seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]];
     }
 
-    function onCloseOrRemove(err) {
-      self.removeSocket(socket);
-      socket.removeListener('free', onFree);
-      socket.removeListener('close', onCloseOrRemove);
-      socket.removeListener('agentRemove', onCloseOrRemove);
+    if (clockseq == null) {
+      // Per 4.2.2, randomize (14 bit) clockseq
+      clockseq = _clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff;
     }
-  });
-};
+  } // UUID timestamps are 100 nano-second units since the Gregorian epoch,
+  // (1582-10-15 00:00).  JSNumbers aren't precise enough for this, so
+  // time is handled internally as 'msecs' (integer milliseconds) and 'nsecs'
+  // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00.
 
-TunnelingAgent.prototype.createSocket = function createSocket(options, cb) {
-  var self = this;
-  var placeholder = {};
-  self.sockets.push(placeholder);
 
-  var connectOptions = mergeOptions({}, self.proxyOptions, {
-    method: 'CONNECT',
-    path: options.host + ':' + options.port,
-    agent: false,
-    headers: {
-      host: options.host + ':' + options.port
-    }
-  });
-  if (options.localAddress) {
-    connectOptions.localAddress = options.localAddress;
+  let msecs = options.msecs !== undefined ? options.msecs : Date.now(); // Per 4.2.1.2, use count of uuid's generated during the current clock
+  // cycle to simulate higher resolution clock
+
+  let nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1; // Time since last uuid creation (in msecs)
+
+  const dt = msecs - _lastMSecs + (nsecs - _lastNSecs) / 10000; // Per 4.2.1.2, Bump clockseq on clock regression
+
+  if (dt < 0 && options.clockseq === undefined) {
+    clockseq = clockseq + 1 & 0x3fff;
+  } // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new
+  // time interval
+
+
+  if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) {
+    nsecs = 0;
+  } // Per 4.2.1.2 Throw error if too many uuids are requested
+
+
+  if (nsecs >= 10000) {
+    throw new Error("uuid.v1(): Can't create more than 10M uuids/sec");
   }
-  if (connectOptions.proxyAuth) {
-    connectOptions.headers = connectOptions.headers || {};
-    connectOptions.headers['Proxy-Authorization'] = 'Basic ' +
-        new Buffer(connectOptions.proxyAuth).toString('base64');
+
+  _lastMSecs = msecs;
+  _lastNSecs = nsecs;
+  _clockseq = clockseq; // Per 4.1.4 - Convert from unix epoch to Gregorian epoch
+
+  msecs += 12219292800000; // `time_low`
+
+  const tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;
+  b[i++] = tl >>> 24 & 0xff;
+  b[i++] = tl >>> 16 & 0xff;
+  b[i++] = tl >>> 8 & 0xff;
+  b[i++] = tl & 0xff; // `time_mid`
+
+  const tmh = msecs / 0x100000000 * 10000 & 0xfffffff;
+  b[i++] = tmh >>> 8 & 0xff;
+  b[i++] = tmh & 0xff; // `time_high_and_version`
+
+  b[i++] = tmh >>> 24 & 0xf | 0x10; // include version
+
+  b[i++] = tmh >>> 16 & 0xff; // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)
+
+  b[i++] = clockseq >>> 8 | 0x80; // `clock_seq_low`
+
+  b[i++] = clockseq & 0xff; // `node`
+
+  for (let n = 0; n < 6; ++n) {
+    b[i + n] = node[n];
   }
 
-  debug('making CONNECT request');
-  var connectReq = self.request(connectOptions);
-  connectReq.useChunkedEncodingByDefault = false; // for v0.6
-  connectReq.once('response', onResponse); // for v0.6
-  connectReq.once('upgrade', onUpgrade);   // for v0.6
-  connectReq.once('connect', onConnect);   // for v0.7 or later
-  connectReq.once('error', onError);
-  connectReq.end();
+  return buf || (0, _stringify.default)(b);
+}
+
+var _default = v1;
+exports["default"] = _default;
+
+/***/ }),
+
+/***/ 6409:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+
+"use strict";
+
 
-  function onResponse(res) {
-    // Very hacky. This is necessary to avoid http-parser leaks.
-    res.upgrade = true;
-  }
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports["default"] = void 0;
 
-  function onUpgrade(res, socket, head) {
-    // Hacky.
-    process.nextTick(function() {
-      onConnect(res, socket, head);
-    });
-  }
+var _v = _interopRequireDefault(__nccwpck_require__(5998));
 
-  function onConnect(res, socket, head) {
-    connectReq.removeAllListeners();
-    socket.removeAllListeners();
+var _md = _interopRequireDefault(__nccwpck_require__(4569));
 
-    if (res.statusCode !== 200) {
-      debug('tunneling socket could not be established, statusCode=%d',
-        res.statusCode);
-      socket.destroy();
-      var error = new Error('tunneling socket could not be established, ' +
-        'statusCode=' + res.statusCode);
-      error.code = 'ECONNRESET';
-      options.request.emit('error', error);
-      self.removeSocket(placeholder);
-      return;
-    }
-    if (head.length > 0) {
-      debug('got illegal response body from proxy');
-      socket.destroy();
-      var error = new Error('got illegal response body from proxy');
-      error.code = 'ECONNRESET';
-      options.request.emit('error', error);
-      self.removeSocket(placeholder);
-      return;
-    }
-    debug('tunneling connection has established');
-    self.sockets[self.sockets.indexOf(placeholder)] = socket;
-    return cb(socket);
-  }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-  function onError(cause) {
-    connectReq.removeAllListeners();
+const v3 = (0, _v.default)('v3', 0x30, _md.default);
+var _default = v3;
+exports["default"] = _default;
 
-    debug('tunneling socket could not be established, cause=%s\n',
-          cause.message, cause.stack);
-    var error = new Error('tunneling socket could not be established, ' +
-                          'cause=' + cause.message);
-    error.code = 'ECONNRESET';
-    options.request.emit('error', error);
-    self.removeSocket(placeholder);
-  }
-};
+/***/ }),
 
-TunnelingAgent.prototype.removeSocket = function removeSocket(socket) {
-  var pos = this.sockets.indexOf(socket)
-  if (pos === -1) {
-    return;
-  }
-  this.sockets.splice(pos, 1);
+/***/ 5998:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
 
-  var pending = this.requests.shift();
-  if (pending) {
-    // If we have pending requests and a socket gets closed a new one
-    // needs to be created to take over in the pool for the one that closed.
-    this.createSocket(pending, function(socket) {
-      pending.request.onSocket(socket);
-    });
-  }
-};
+"use strict";
 
-function createSecureSocket(options, cb) {
-  var self = this;
-  TunnelingAgent.prototype.createSocket.call(self, options, function(socket) {
-    var hostHeader = options.request.getHeader('host');
-    var tlsOptions = mergeOptions({}, self.options, {
-      socket: socket,
-      servername: hostHeader ? hostHeader.replace(/:.*$/, '') : options.host
-    });
 
-    // 0 is dummy port for v0.6
-    var secureSocket = tls.connect(0, tlsOptions);
-    self.sockets[self.sockets.indexOf(socket)] = secureSocket;
-    cb(secureSocket);
-  });
-}
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports["default"] = _default;
+exports.URL = exports.DNS = void 0;
 
+var _stringify = _interopRequireDefault(__nccwpck_require__(8950));
 
-function toOptions(host, port, localAddress) {
-  if (typeof host === 'string') { // since v0.10
-    return {
-      host: host,
-      port: port,
-      localAddress: localAddress
-    };
+var _parse = _interopRequireDefault(__nccwpck_require__(2746));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function stringToBytes(str) {
+  str = unescape(encodeURIComponent(str)); // UTF8 escape
+
+  const bytes = [];
+
+  for (let i = 0; i < str.length; ++i) {
+    bytes.push(str.charCodeAt(i));
   }
-  return host; // for v0.11 or later
+
+  return bytes;
 }
 
-function mergeOptions(target) {
-  for (var i = 1, len = arguments.length; i < len; ++i) {
-    var overrides = arguments[i];
-    if (typeof overrides === 'object') {
-      var keys = Object.keys(overrides);
-      for (var j = 0, keyLen = keys.length; j < keyLen; ++j) {
-        var k = keys[j];
-        if (overrides[k] !== undefined) {
-          target[k] = overrides[k];
-        }
+const DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
+exports.DNS = DNS;
+const URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';
+exports.URL = URL;
+
+function _default(name, version, hashfunc) {
+  function generateUUID(value, namespace, buf, offset) {
+    if (typeof value === 'string') {
+      value = stringToBytes(value);
+    }
+
+    if (typeof namespace === 'string') {
+      namespace = (0, _parse.default)(namespace);
+    }
+
+    if (namespace.length !== 16) {
+      throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)');
+    } // Compute hash of namespace and value, Per 4.3
+    // Future: Use spread syntax when supported on all platforms, e.g. `bytes =
+    // hashfunc([...namespace, ... value])`
+
+
+    let bytes = new Uint8Array(16 + value.length);
+    bytes.set(namespace);
+    bytes.set(value, namespace.length);
+    bytes = hashfunc(bytes);
+    bytes[6] = bytes[6] & 0x0f | version;
+    bytes[8] = bytes[8] & 0x3f | 0x80;
+
+    if (buf) {
+      offset = offset || 0;
+
+      for (let i = 0; i < 16; ++i) {
+        buf[offset + i] = bytes[i];
       }
+
+      return buf;
     }
-  }
-  return target;
+
+    return (0, _stringify.default)(bytes);
+  } // Function#name is not settable on some platforms (#270)
+
+
+  try {
+    generateUUID.name = name; // eslint-disable-next-line no-empty
+  } catch (err) {} // For CommonJS default export support
+
+
+  generateUUID.DNS = DNS;
+  generateUUID.URL = URL;
+  return generateUUID;
 }
 
+/***/ }),
 
-var debug;
-if (process.env.NODE_DEBUG && /\btunnel\b/.test(process.env.NODE_DEBUG)) {
-  debug = function() {
-    var args = Array.prototype.slice.call(arguments);
-    if (typeof args[0] === 'string') {
-      args[0] = 'TUNNEL: ' + args[0];
-    } else {
-      args.unshift('TUNNEL:');
+/***/ 5122:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports["default"] = void 0;
+
+var _rng = _interopRequireDefault(__nccwpck_require__(807));
+
+var _stringify = _interopRequireDefault(__nccwpck_require__(8950));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function v4(options, buf, offset) {
+  options = options || {};
+
+  const rnds = options.random || (options.rng || _rng.default)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
+
+
+  rnds[6] = rnds[6] & 0x0f | 0x40;
+  rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided
+
+  if (buf) {
+    offset = offset || 0;
+
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
     }
-    console.error.apply(console, args);
+
+    return buf;
   }
-} else {
-  debug = function() {};
+
+  return (0, _stringify.default)(rnds);
 }
-exports.debug = debug; // for test
 
+var _default = v4;
+exports["default"] = _default;
 
 /***/ }),
 
-/***/ 5030:
-/***/ ((__unused_webpack_module, exports) => {
+/***/ 9120:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
 
 "use strict";
 
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-
-function getUserAgent() {
-  if (typeof navigator === "object" && "userAgent" in navigator) {
-    return navigator.userAgent;
-  }
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports["default"] = void 0;
 
-  if (typeof process === "object" && "version" in process) {
-    return `Node.js/${process.version.substr(1)} (${process.platform}; ${process.arch})`;
-  }
+var _v = _interopRequireDefault(__nccwpck_require__(5998));
 
-  return "<environment undetectable>";
-}
+var _sha = _interopRequireDefault(__nccwpck_require__(5274));
 
-exports.getUserAgent = getUserAgent;
-//# sourceMappingURL=index.js.map
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+const v5 = (0, _v.default)('v5', 0x50, _sha.default);
+var _default = v5;
+exports["default"] = _default;
 
 /***/ }),
 
-/***/ 1463:
-/***/ ((__unused_webpack_module, exports) => {
+/***/ 6900:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
 
 "use strict";
 
 
-exports.fromCallback = function (fn) {
-  return Object.defineProperty(function (...args) {
-    if (typeof args[args.length - 1] === 'function') fn.apply(this, args)
-    else {
-      return new Promise((resolve, reject) => {
-        fn.call(
-          this,
-          ...args,
-          (err, res) => (err != null) ? reject(err) : resolve(res)
-        )
-      })
-    }
-  }, 'name', { value: fn.name })
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports["default"] = void 0;
+
+var _regex = _interopRequireDefault(__nccwpck_require__(814));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function validate(uuid) {
+  return typeof uuid === 'string' && _regex.default.test(uuid);
 }
 
-exports.fromPromise = function (fn) {
-  return Object.defineProperty(function (...args) {
-    const cb = args[args.length - 1]
-    if (typeof cb !== 'function') return fn.apply(this, args)
-    else fn.apply(this, args.slice(0, -1)).then(r => cb(null, r), cb)
-  }, 'name', { value: fn.name })
+var _default = validate;
+exports["default"] = _default;
+
+/***/ }),
+
+/***/ 1595:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports["default"] = void 0;
+
+var _validate = _interopRequireDefault(__nccwpck_require__(6900));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function version(uuid) {
+  if (!(0, _validate.default)(uuid)) {
+    throw TypeError('Invalid UUID');
+  }
+
+  return parseInt(uuid.substr(14, 1), 16);
 }
 
+var _default = version;
+exports["default"] = _default;
 
 /***/ }),
 
@@ -21242,6 +29794,7 @@ const path = __nccwpck_require__(1017)
 const { getInput } = __nccwpck_require__(4623)
 
 const REPLACE_DEFAULT = true
+const TEMPLATE_DEFAULT = false
 const DELETE_ORPHANED_DEFAULT = false
 
 let context
@@ -21411,20 +29964,14 @@ const parseExclude = (text, src) => {
 
 const parseFiles = (files) => {
 	return files.map((item) => {
-
-		if (typeof item === 'string') {
-			return {
-				source: item,
-				dest: item,
-				replace: REPLACE_DEFAULT,
-				deleteOrphaned: DELETE_ORPHANED_DEFAULT
-			}
-		}
+		if (typeof item === 'string')
+			item = { source: item }
 
 		if (item.source !== undefined) {
 			return {
 				source: item.source,
 				dest: item.dest || item.source,
+				template: item.template === undefined ? TEMPLATE_DEFAULT : item.template,
 				replace: item.replace === undefined ? REPLACE_DEFAULT : item.replace,
 				deleteOrphaned: item.deleteOrphaned === undefined ? DELETE_ORPHANED_DEFAULT : item.deleteOrphaned,
 				exclude: parseExclude(item.exclude, item.source)
@@ -22031,6 +30578,9 @@ const readfiles = __nccwpck_require__(5884)
 const { exec } = __nccwpck_require__(2081)
 const core = __nccwpck_require__(2186)
 const path = __nccwpck_require__(1017)
+const nunjucks = __nccwpck_require__(7006)
+
+nunjucks.configure({ autoescape: true, trimBlocks: true, lstripBlocks: true })
 
 // From https://github.com/toniov/p-iteration/blob/master/lib/static-methods.js - MIT © Antonio V
 const forEach = async (array, callback) => {
@@ -22091,13 +30641,19 @@ const pathIsDirectory = async (path) => {
 	return stat.isDirectory()
 }
 
-const copy = async (src, dest, deleteOrphaned, exclude) => {
+const write = async (src, dest, context) => {
+	if (typeof context !== 'object') {
+		context = {}
+	}
+	const content = nunjucks.render(src, context)
+	await fs.outputFile(dest, content)
+}
 
-	core.debug(`CP: ${ src } TO ${ dest }`)
+const copy = async (src, dest, isDirectory, file) => {
+	const deleteOrphaned = isDirectory && file.deleteOrphaned
 
 	const filterFunc = (file) => {
-
-		if (exclude !== undefined && exclude.includes(file)) {
+		if (file.exclude !== undefined && file.exclude.includes(file)) {
 			core.debug(`Excluding file ${ file }`)
 			return false
 		}
@@ -22105,7 +30661,28 @@ const copy = async (src, dest, deleteOrphaned, exclude) => {
 		return true
 	}
 
-	await fs.copy(src, dest, exclude !== undefined && { filter: filterFunc })
+	if (file.template) {
+		if (isDirectory) {
+			core.debug(`Render all files in directory ${ src } to ${ dest }`)
+
+			const srcFileList = await readfiles(src, { readContents: false, hidden: true })
+			for (const file of srcFileList) {
+				if (!filterFunc(file)) { continue }
+
+				const srcPath = path.join(src, file)
+				const destPath = path.join(dest, file)
+				await write(srcPath, destPath, file.template)
+			}
+		} else {
+			core.debug(`Render file ${ src } to ${ dest }`)
+
+			await write(src, dest, file.template)
+		}
+	} else {
+		core.debug(`Copy ${ src } to ${ dest }`)
+		await fs.copy(src, dest, file.exclude !== undefined && { filter: filterFunc })
+	}
+
 
 	// If it is a directory and deleteOrphaned is enabled - check if there are any files that were removed from source dir and remove them in destination dir
 	if (deleteOrphaned) {
@@ -22149,6 +30726,14 @@ module.exports = {
 	arrayEquals
 }
 
+/***/ }),
+
+/***/ 561:
+/***/ ((module) => {
+
+module.exports = eval("require")("chokidar");
+
+
 /***/ }),
 
 /***/ 2877:
@@ -22183,6 +30768,22 @@ module.exports = require("constants");
 
 /***/ }),
 
+/***/ 6113:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("crypto");
+
+/***/ }),
+
+/***/ 3639:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("domain");
+
+/***/ }),
+
 /***/ 2361:
 /***/ ((module) => {
 
@@ -22411,9 +31012,7 @@ const run = async () => {
 
 				if (isDirectory) core.info(`Source is directory`)
 
-				const deleteOrphaned = isDirectory && file.deleteOrphaned
-
-				await copy(source, dest, deleteOrphaned, file.exclude)
+				await copy(source, dest, isDirectory, file)
 
 				await git.add(file.dest)
 

From 2badd0c6bf4ee5b7de67d571c781e31906a98fb6 Mon Sep 17 00:00:00 2001
From: Dhruv Bhanushali <dhruv_b@live.com>
Date: Sat, 12 Nov 2022 23:34:16 +0400
Subject: [PATCH 5/6] Add documentation about the templating feature

---
 README.md | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/README.md b/README.md
index 5141a8af..49e63b4d 100644
--- a/README.md
+++ b/README.md
@@ -202,6 +202,29 @@ user/repo:
     replace: false
 ```
 
+### Render Jinja-style templates
+
+If a file contains [Jinja](https://jinja.palletsprojects.com/)-style template syntax, it can be compiled using [Nunjucks](https://mozilla.github.io/nunjucks/) and the output written to the specific folders. Supports variables and blocks among other things. To enable, set the `template` field to a context dictionary, or in case of no variables, `true`:
+
+```yml
+user/repo:
+  - source: .github/workflows/child.yml
+    template:
+      a:
+        b: 'val'
+```
+
+In the source file, you can use `extends` with a relative path and variables as defined in the context. Additional [template syntax](https://mozilla.github.io/nunjucks/templating.html) will _most likely_ work too.
+
+```yml
+# child.yml
+{% extends './parent.yml' %}
+
+{% block some_block %}
+{{ a.b }}
+{% endblock %}
+```
+
 ### Delete orphaned files
 
 With the `deleteOrphaned` option you can choose to delete files in the target repository if they are deleted in the source repository. The option defaults to `false` and only works when [syncing entire directories](#sync-entire-directories):

From 4eb1d52706e3c0c195d9647b359caaf70d101089 Mon Sep 17 00:00:00 2001
From: Maximilian Schiller <schiller@mxis.ch>
Date: Thu, 17 Nov 2022 18:41:03 +0100
Subject: [PATCH 6/6] update readme

---
 README.md | 40 +++++++++++++++++++++++++++++++++-------
 1 file changed, 33 insertions(+), 7 deletions(-)

diff --git a/README.md b/README.md
index 49e63b4d..93f22864 100644
--- a/README.md
+++ b/README.md
@@ -20,6 +20,7 @@ With [repo-file-sync-action](https://github.com/BetaHuhn/repo-file-sync-action)
 - Create a pull request in the target repo so you have the last say on what gets merged
 - Automatically label pull requests to integrate with other actions like [automerge-action](https://github.com/pascalgn/automerge-action)
 - Assign users to the pull request
+- Render [Jinja](https://jinja.palletsprojects.com/)-style templates as use variables thanks to [Nunjucks](https://mozilla.github.io/nunjucks/)
 
 ## 📚 Usage
 
@@ -202,26 +203,51 @@ user/repo:
     replace: false
 ```
 
-### Render Jinja-style templates
+### Using templates
 
-If a file contains [Jinja](https://jinja.palletsprojects.com/)-style template syntax, it can be compiled using [Nunjucks](https://mozilla.github.io/nunjucks/) and the output written to the specific folders. Supports variables and blocks among other things. To enable, set the `template` field to a context dictionary, or in case of no variables, `true`:
+You can render templates before syncing by using the [Jinja](https://jinja.palletsprojects.com/)-style template syntax. It will be compiled using [Nunjucks](https://mozilla.github.io/nunjucks/) and the output written to the specific file(s) or folder(s).
+
+Nunjucks supports variables and blocks among other things. To enable, set the `template` field to a context dictionary, or in case of no variables, `true`:
 
 ```yml
 user/repo:
-  - source: .github/workflows/child.yml
+  - source: src/README.md
     template:
-      a:
-        b: 'val'
+      user:
+        name: 'Maxi'
+        handle: '@BetaHuhn'
 ```
 
-In the source file, you can use `extends` with a relative path and variables as defined in the context. Additional [template syntax](https://mozilla.github.io/nunjucks/templating.html) will _most likely_ work too.
+In the source file you can then use these variables like this:
+
+```yml
+# README.md
+
+Created by {{ user.name }} ({{ user.handle }})
+```
+
+Result:
+
+```yml
+# README.md
+
+Created by Maxi (@BetaHuhn)
+```
+
+You can also use `extends` with a relative path to inherit other templates. Take a look at Nunjucks [template syntax](https://mozilla.github.io/nunjucks/templating.html) for more info.
+
+```yml
+user/repo:
+  - source: .github/workflows/child.yml
+    template: true
+```
 
 ```yml
 # child.yml
 {% extends './parent.yml' %}
 
 {% block some_block %}
-{{ a.b }}
+This is some content
 {% endblock %}
 ```