@rhinostone/swig 2.0.1 → 2.2.0

package/dist/swig.js

@@ -1,4 +1,4 @@
-/*! Swig v2.0.1 | https://github.com/gina-io/swig | @license https://github.com/gina-io/swig/blob/master/LICENSE */
+/*! Swig v2.2.0 | https://github.com/gina-io/swig | @license https://github.com/gina-io/swig/blob/master/LICENSE */
 /*! DateZ (c) 2011 Tomo Universalis | @license https://github.com/ocrybit/DateZ/blob/master/LISENCE */
 (() => {
   var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -275,6 +275,49 @@
       exports.legacyJS = function(js, loc) {
         return withLoc({ type: "LegacyJS", js }, loc);
       };
+      exports.extendsDeferred = function(path, childBlocks, childIRs, resolveFrom, loc) {
+        var node = { type: "ExtendsDeferred", path };
+        if (childBlocks !== void 0) {
+          node.childBlocks = childBlocks;
+        }
+        if (childIRs !== void 0) {
+          node.childIRs = childIRs;
+        }
+        if (resolveFrom !== void 0) {
+          node.resolveFrom = resolveFrom;
+        }
+        return withLoc(node, loc);
+      };
+      exports.includeDeferred = function(path, context, isolated, ignoreMissing, resolveFrom, loc) {
+        var node = { type: "IncludeDeferred", path };
+        if (context !== void 0) {
+          node.context = context;
+        }
+        if (isolated !== void 0) {
+          node.isolated = isolated;
+        }
+        if (ignoreMissing !== void 0) {
+          node.ignoreMissing = ignoreMissing;
+        }
+        if (resolveFrom !== void 0) {
+          node.resolveFrom = resolveFrom;
+        }
+        return withLoc(node, loc);
+      };
+      exports.importDeferred = function(path, alias, resolveFrom, loc) {
+        var node = { type: "ImportDeferred", path, alias };
+        if (resolveFrom !== void 0) {
+          node.resolveFrom = resolveFrom;
+        }
+        return withLoc(node, loc);
+      };
+      exports.fromImportDeferred = function(path, imports, resolveFrom, loc) {
+        var node = { type: "FromImportDeferred", path, imports };
+        if (resolveFrom !== void 0) {
+          node.resolveFrom = resolveFrom;
+        }
+        return withLoc(node, loc);
+      };
       exports.literal = function(kind, value, loc) {
         return withLoc({ type: "Literal", kind, value }, loc);
       };
@@ -801,32 +844,40 @@
       exports["default"] = function(input, def) {
         return typeof input !== "undefined" && (input || typeof input === "number") ? input : def;
       };
+      function escapeHtmlRest(ch) {
+        return ch === "<" ? "&lt;" : ch === ">" ? "&gt;" : ch === '"' ? "&quot;" : "&#39;";
+      }
       exports.escape = function(input, type) {
-        var out = iterateFilter.apply(exports.escape, arguments), inp = input, i = 0, code;
-        if (out !== void 0) {
-          return out;
+        var t, inp, out, i, code;
+        if (input === null || input === void 0) {
+          return input;
         }
-        if (typeof input !== "string") {
+        t = typeof input;
+        if (t !== "string") {
+          if (t === "object") {
+            out = iterateFilter.apply(exports.escape, arguments);
+            if (out !== void 0) {
+              return out;
+            }
+          }
           return input;
         }
-        out = "";
-        switch (type) {
-          case "js":
-            inp = inp.replace(/\\/g, "\\u005C");
-            for (i; i < inp.length; i += 1) {
-              code = inp.charCodeAt(i);
-              if (code < 32) {
-                code = code.toString(16).toUpperCase();
-                code = code.length < 2 ? "0" + code : code;
-                out += "\\u00" + code;
-              } else {
-                out += inp[i];
-              }
+        if (type === "js") {
+          inp = input.replace(/\\/g, "\\u005C");
+          out = "";
+          for (i = 0; i < inp.length; i += 1) {
+            code = inp.charCodeAt(i);
+            if (code < 32) {
+              code = code.toString(16).toUpperCase();
+              code = code.length < 2 ? "0" + code : code;
+              out += "\\u00" + code;
+            } else {
+              out += inp[i];
             }
-            return out.replace(/&/g, "\\u0026").replace(/</g, "\\u003C").replace(/>/g, "\\u003E").replace(/\'/g, "\\u0027").replace(/"/g, "\\u0022").replace(/\=/g, "\\u003D").replace(/-/g, "\\u002D").replace(/;/g, "\\u003B");
-          default:
-            return inp.replace(/&(?!amp;|lt;|gt;|quot;|#39;)/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+          }
+          return out.replace(/&/g, "\\u0026").replace(/</g, "\\u003C").replace(/>/g, "\\u003E").replace(/\'/g, "\\u0027").replace(/"/g, "\\u0022").replace(/\=/g, "\\u003D").replace(/-/g, "\\u002D").replace(/;/g, "\\u003B");
         }
+        return input.replace(/&(?!amp;|lt;|gt;|quot;|#39;)/g, "&amp;").replace(/[<>"']/g, escapeHtmlRest);
       };
       exports.e = exports.escape;
       exports.first = function(input) {
@@ -1345,6 +1396,12 @@
               macroIndexOfJS = '"' + macroParams.join('","') + '"';
             }
             out += "_ctx." + node.name + " = function (" + macroSigJS + ') {\n  var _output = "",\n    __ctx = _utils.extend({}, _ctx);\n  _utils.each(_ctx, function (v, k) {\n    if ([' + macroIndexOfJS + "].indexOf(k) !== -1) { delete _ctx[k]; }\n  });\n" + macroBodyJS + "\n _ctx = _utils.extend(_ctx, __ctx);\n  return _output;\n};\n_ctx." + node.name + ".safe = true;\n";
+            if (options && options.codegenMode === "async") {
+              if (_security.dangerousProps.indexOf(node.name) !== -1) {
+                throw new Error('Macro name "' + node.name + '" is reserved.');
+              }
+              out += "_exports." + node.name + " = _ctx." + node.name + ";\n";
+            }
             return;
           }
           if (node.type === "Parent") {
@@ -1361,6 +1418,24 @@
             return;
           }
           if (node.type === "Block") {
+            if (options && options.codegenMode === "async") {
+              var blockNameJS = JSON.stringify(node.name);
+              out += "if (_blocks && _blocks[" + blockNameJS + "]) {\n";
+              out += "  _output += await _blocks[" + blockNameJS + "](_ctx);\n";
+              out += "} else {\n";
+              utils.each(node.body, function(b) {
+                if (b.type === "LegacyJS") {
+                  out += b.js;
+                  return;
+                }
+                if (b.type === "Text" || b.type === "Raw") {
+                  out += '_output += "' + escapeTextValue(b.value) + '";\n';
+                  return;
+                }
+              });
+              out += "}\n";
+              return;
+            }
             utils.each(node.body, function(b) {
               if (b.type === "LegacyJS") {
                 out += b.js;
@@ -1398,6 +1473,106 @@
             out += (node.ignoreMissing ? "  try {\n" : "") + "_output += _swig.compileFile(" + incPathJS + ', {resolveFrom: "' + node.resolveFrom + '"})(' + incSelector + ");\n" + (node.ignoreMissing ? "} catch (e) {}\n" : "");
             return;
           }
+          if (node.type === "IncludeDeferred") {
+            var incdPathJS, incdCtxJS;
+            if (node.path && typeof node.path === "object" && typeof node.path.type === "string") {
+              incdPathJS = exports.emitExpr(node.path);
+            } else {
+              incdPathJS = node.path;
+            }
+            if (node.context !== void 0) {
+              if (typeof node.context === "object" && typeof node.context.type === "string") {
+                incdCtxJS = exports.emitExpr(node.context);
+              } else {
+                incdCtxJS = node.context;
+              }
+            }
+            var incdSelector;
+            if (node.isolated && incdCtxJS) {
+              incdSelector = incdCtxJS;
+            } else if (!incdCtxJS) {
+              incdSelector = "_ctx";
+            } else {
+              incdSelector = "_utils.extend({}, _ctx, " + incdCtxJS + ")";
+            }
+            var incdOpts = '{resolveFrom: "' + (node.resolveFrom || "") + '"}';
+            out += (node.ignoreMissing ? "  try {\n" : "") + "_output += (await (await _swig.getTemplate(" + incdPathJS + ", " + incdOpts + "))(" + incdSelector + ")).output;\n" + (node.ignoreMissing ? "} catch (e) {}\n" : "");
+            return;
+          }
+          if (node.type === "ImportDeferred") {
+            if (_security.dangerousProps.indexOf(node.alias) !== -1) {
+              throw new Error('Import alias "' + node.alias + '" is reserved.');
+            }
+            var impdPathJS;
+            if (node.path && typeof node.path === "object" && typeof node.path.type === "string") {
+              impdPathJS = exports.emitExpr(node.path);
+            } else {
+              impdPathJS = node.path;
+            }
+            var impdOpts = '{resolveFrom: "' + (node.resolveFrom || "") + '"}';
+            out += "_ctx." + node.alias + " = (await (await _swig.getTemplate(" + impdPathJS + ", " + impdOpts + "))(_ctx)).exports;\n";
+            return;
+          }
+          if (node.type === "FromImportDeferred") {
+            var fromdImports = node.imports || [];
+            utils.each(fromdImports, function(entry) {
+              if (_security.dangerousProps.indexOf(entry.name) !== -1) {
+                throw new Error('From-import name "' + entry.name + '" is reserved.');
+              }
+              var bindName = entry.alias || entry.name;
+              if (_security.dangerousProps.indexOf(bindName) !== -1) {
+                throw new Error('From-import binding "' + bindName + '" is reserved.');
+              }
+            });
+            var fromdPathJS;
+            if (node.path && typeof node.path === "object" && typeof node.path.type === "string") {
+              fromdPathJS = exports.emitExpr(node.path);
+            } else {
+              fromdPathJS = node.path;
+            }
+            var fromdOpts = '{resolveFrom: "' + (node.resolveFrom || "") + '"}';
+            var fromdBindings = "";
+            utils.each(fromdImports, function(entry) {
+              var bindName = entry.alias || entry.name;
+              fromdBindings += "  _ctx." + bindName + ' = _imp["' + entry.name + '"];\n';
+            });
+            out += "await (async function () {\n  var _imp = (await (await _swig.getTemplate(" + fromdPathJS + ", " + fromdOpts + "))(_ctx)).exports;\n" + fromdBindings + "})();\n";
+            return;
+          }
+          if (node.type === "ExtendsDeferred") {
+            if (node.childIRs && node.childIRs.length) {
+              out += exports.compile(node.childIRs, parents, options);
+            }
+            out += "var _localChildBlocks = {};\n";
+            if (node.childBlocks) {
+              utils.each(node.childBlocks, function(block, name) {
+                var blockBodyJS = "";
+                utils.each(block.body, function(b) {
+                  if (b.type === "LegacyJS") {
+                    blockBodyJS += b.js;
+                    return;
+                  }
+                  if (b.type === "Text" || b.type === "Raw") {
+                    blockBodyJS += '_output += "' + escapeTextValue(b.value) + '";\n';
+                    return;
+                  }
+                });
+                out += "_localChildBlocks[" + JSON.stringify(name) + '] = async function (_ctx) {\n  var _output = "";\n' + blockBodyJS + "  return _output;\n};\n";
+              });
+            }
+            out += "var _mergedBlocks = _utils.extend({}, _localChildBlocks, _blocks || {});\n";
+            var extPathJS;
+            if (node.path && typeof node.path === "object" && typeof node.path.type === "string") {
+              extPathJS = exports.emitExpr(node.path);
+            } else {
+              extPathJS = node.path;
+            }
+            var extOpts = '{resolveFrom: "' + (node.resolveFrom || "") + '"}';
+            out += "var _parentTpl = await _swig.getTemplate(" + extPathJS + ", " + extOpts + ");\n";
+            out += "var _parentResult = await _parentTpl(_ctx, _mergedBlocks);\n";
+            out += "_output = _parentResult.output;\n";
+            return;
+          }
           if (node.type === "With") {
             var withCtxJS;
             if (node.context !== void 0) {
@@ -1575,12 +1750,8 @@
         return build;
       }
       function checkMatchExpr(match) {
-        var result;
-        function buildDot(ctx) {
-          return "(" + checkDotExpr(match, ctx) + " ? " + ctx + match.join(".") + ' : "")';
-        }
-        result = "(" + checkDotExpr(match, "_ctx.") + " ? " + buildDot("_ctx.") + " : " + buildDot("") + ")";
-        return "(" + result + " !== null ? " + result + ' : "" )';
+        var leaf = match.join(".");
+        return "(" + checkDotExpr(match, "_ctx.") + " ? _ctx." + leaf + " : (" + checkDotExpr(match, "") + " ? " + leaf + ' : ""))';
       }
       function emitAccess(node, d) {
         if (node.key && node.key.type === "Literal" && node.key.kind === "string") {
@@ -2652,7 +2823,7 @@
          * @private
          */
         checkMatch: function(match) {
-          var temp = match[0], result;
+          var temp = match[0], leaf = match.join(".");
           function checkDot(ctx) {
             var c = ctx + temp, m = match, build = "";
             build = "(typeof " + c + ' !== "undefined" && ' + c + " !== null";
@@ -2666,11 +2837,7 @@
             build += ")";
             return build;
           }
-          function buildDot(ctx) {
-            return "(" + checkDot(ctx) + " ? " + ctx + match.join(".") + ' : "")';
-          }
-          result = "(" + checkDot("_ctx.") + " ? " + buildDot("_ctx.") + " : " + buildDot("") + ")";
-          return "(" + result + " !== null ? " + result + ' : "" )';
+          return "(" + checkDot("_ctx.") + " ? _ctx." + leaf + " : (" + checkDot("") + " ? " + leaf + ' : ""))';
         }
       };
       exports.TokenParser = TokenParser;
@@ -2834,9 +3001,19 @@
   var require_import = __commonJS({
     "lib/tags/import.js"(exports) {
       var utils = require_utils2();
+      var ir = require_ir();
       var backend = require_backend();
       var _dangerousProps = require_security().dangerousProps;
-      exports.compile = function(compiler, args) {
+      exports.compile = function(compiler, args, content, parents, options) {
+        if (options && options.codegenMode === "async") {
+          var asyncAlias = args[args.length - 1];
+          var asyncPath = args[0].path;
+          return ir.importDeferred(
+            ir.literal("string", asyncPath),
+            asyncAlias,
+            options.filename || ""
+          );
+        }
         var ctx = args.pop(), allMacros = utils.map(args, function(arg) {
           return arg.name;
         }).join("|"), out = "_ctx." + ctx + ' = {};\n  var _output = "";\n', replacements = utils.map(args, function(arg) {
@@ -2855,27 +3032,31 @@
         return out;
       };
       exports.parse = function(str, line, parser, types, stack, opts, swig2) {
-        var compiler = require_parser().compile, parseOpts = { resolveFrom: opts.filename }, compileOpts = utils.extend({}, opts, parseOpts), tokens, ctx;
+        var compiler = require_parser().compile, parseOpts = { resolveFrom: opts.filename }, compileOpts = utils.extend({}, opts, parseOpts), isAsync = !!(opts && opts.codegenMode === "async"), importPath, ctx;
         parser.on(types.STRING, function(token) {
           var self = this;
-          if (!tokens) {
-            tokens = swig2.parseFile(token.match.replace(/^("|')|("|')$/g, ""), parseOpts).tokens;
-            utils.each(tokens, function(token2) {
-              var out = "", macroName;
-              if (!token2 || token2.name !== "macro" || !token2.compile) {
-                return;
-              }
-              macroName = token2.args[0];
-              out += backend.compile([token2.compile(compiler, token2.args, token2.content, [], compileOpts)], [], compileOpts) + "\n";
-              self.out.push({ compiled: out, name: macroName });
-            });
+          if (importPath !== void 0) {
+            throw new Error("Unexpected string " + token.match + " on line " + line + ".");
+          }
+          importPath = token.match.replace(/^("|')|("|')$/g, "");
+          if (isAsync) {
+            self.out.push({ path: importPath });
             return;
           }
-          throw new Error("Unexpected string " + token.match + " on line " + line + ".");
+          var tokens = swig2.parseFile(importPath, parseOpts).tokens;
+          utils.each(tokens, function(token2) {
+            var out = "", macroName;
+            if (!token2 || token2.name !== "macro" || !token2.compile) {
+              return;
+            }
+            macroName = token2.args[0];
+            out += backend.compile([token2.compile(compiler, token2.args, token2.content, [], compileOpts)], [], compileOpts) + "\n";
+            self.out.push({ compiled: out, name: macroName });
+          });
         });
         parser.on(types.VAR, function(token) {
           var self = this;
-          if (!tokens || ctx) {
+          if (importPath === void 0 || ctx) {
             throw new Error('Unexpected variable "' + token.match + '" on line ' + line + ".");
           }
           if (token.match === "as") {
@@ -2912,6 +3093,9 @@
             w = void 0;
           }
         }
+        if (options && options.codegenMode === "async") {
+          return ir.includeDeferred(file, w || void 0, !!onlyCtx, !!ignoreMissing, parentFile);
+        }
         return ir.include(file, w || void 0, !!onlyCtx, !!ignoreMissing, parentFile);
       };
       exports.lowerExpr = function(parser, tokens) {
@@ -3789,6 +3973,155 @@
     }
   });
 
+  // lib/async/pre-walker.js
+  var require_pre_walker = __commonJS({
+    "lib/async/pre-walker.js"(exports) {
+      var utils = require_utils2();
+      function escapeRegExp(str) {
+        return str.replace(/[\-\/\\\^$*+?.()|\[\]{}]/g, "\\$&");
+      }
+      function buildSplitter(controls) {
+        var anyChar = "[\\s\\S]*?", varOpen = escapeRegExp(controls.varControls[0]), varClose = escapeRegExp(controls.varControls[1]), tagOpen = escapeRegExp(controls.tagControls[0]), tagClose = escapeRegExp(controls.tagControls[1]), cmtOpen = escapeRegExp(controls.cmtControls[0]), cmtClose = escapeRegExp(controls.cmtControls[1]);
+        return new RegExp(
+          "(" + tagOpen + anyChar + tagClose + "|" + varOpen + anyChar + varClose + "|" + cmtOpen + anyChar + cmtClose + ")"
+        );
+      }
+      function stripTagBody(chunk, tagOpen, tagClose) {
+        var body = chunk.substr(tagOpen.length, chunk.length - tagOpen.length - tagClose.length);
+        if (body.charAt(0) === "-") {
+          body = body.substr(1);
+        }
+        if (body.charAt(body.length - 1) === "-") {
+          body = body.substr(0, body.length - 1);
+        }
+        return body.replace(/^\s+|\s+$/g, "");
+      }
+      exports.scan = function(source, opts) {
+        source = source.replace(/\r\n/g, "\n");
+        var splitter = buildSplitter(opts), tagOpen = opts.tagControls[0], tagClose = opts.tagControls[1], rawTag = opts.rawTag, endRawTag = "end" + rawTag, keywordRegex = new RegExp(
+          "^(" + opts.keywords.join("|") + `)\\s+["\\']([^"\\']+)["\\']`
+        ), chunks = source.split(splitter), results = [], inRaw = false, i, chunk, body, name, m;
+        for (i = 0; i < chunks.length; i += 1) {
+          chunk = chunks[i];
+          if (typeof chunk !== "string" || !chunk) {
+            continue;
+          }
+          if (!utils.startsWith(chunk, tagOpen) || !utils.endsWith(chunk, tagClose)) {
+            continue;
+          }
+          body = stripTagBody(chunk, tagOpen, tagClose);
+          name = body.split(/\s+/)[0];
+          if (name === rawTag) {
+            inRaw = true;
+            continue;
+          }
+          if (name === endRawTag) {
+            inRaw = false;
+            continue;
+          }
+          if (inRaw) {
+            continue;
+          }
+          m = keywordRegex.exec(body);
+          if (m) {
+            results.push({ kind: m[1], path: m[2] });
+          }
+        }
+        return results;
+      };
+      exports.walk = function(entryPath, loader, scanOpts) {
+        var memMap = {};
+        var pending = {};
+        return new Promise(function(resolve, reject) {
+          var inFlight = 0;
+          var queue = [];
+          var hasError = false;
+          function enqueue(path) {
+            if (memMap.hasOwnProperty(path) || pending[path]) {
+              return;
+            }
+            pending[path] = true;
+            queue.push(path);
+          }
+          function drain() {
+            while (queue.length > 0 && !hasError) {
+              var path = queue.shift();
+              inFlight += 1;
+              startLoad(path);
+            }
+            if (inFlight === 0 && !hasError && queue.length === 0) {
+              resolve(memMap);
+            }
+          }
+          function startLoad(resolvedPath) {
+            loader.load(resolvedPath, function(err, src) {
+              if (hasError) {
+                return;
+              }
+              if (err) {
+                hasError = true;
+                reject(err);
+                return;
+              }
+              if (typeof src !== "string") {
+                hasError = true;
+                reject(new Error('Async loader returned non-string source for "' + resolvedPath + '"'));
+                return;
+              }
+              memMap[resolvedPath] = src;
+              var targets;
+              try {
+                targets = exports.scan(src, scanOpts);
+              } catch (e) {
+                hasError = true;
+                reject(e);
+                return;
+              }
+              var i, resolvedChild;
+              for (i = 0; i < targets.length; i += 1) {
+                try {
+                  resolvedChild = loader.resolve(targets[i].path, resolvedPath);
+                } catch (e) {
+                  hasError = true;
+                  reject(e);
+                  return;
+                }
+                enqueue(resolvedChild);
+              }
+              inFlight -= 1;
+              drain();
+            });
+          }
+          enqueue(entryPath);
+          drain();
+        });
+      };
+      exports.makeMemoryWrapper = function(userLoader, memMap) {
+        return {
+          resolve: function(to, from) {
+            return userLoader.resolve(to, from);
+          },
+          load: function(id, cb) {
+            var src = memMap[id];
+            if (typeof src !== "string") {
+              var err = new Error('Pre-walked map missing path: "' + id + '"');
+              if (cb) {
+                cb(err);
+                return;
+              }
+              throw err;
+            }
+            if (cb) {
+              cb(null, src);
+              return;
+            }
+            return src;
+          }
+        };
+      };
+    }
+  });
+
   // packages/swig-core/lib/cache.js
   var require_cache = __commonJS({
     "packages/swig-core/lib/cache.js"(exports) {
@@ -3822,8 +4155,11 @@
   var require_engine = __commonJS({
     "packages/swig-core/lib/engine.js"(exports) {
       var utils = require_utils();
+      var ir = require_ir();
       var backend = require_backend();
       var cache = require_cache();
+      var AsyncFunction = Object.getPrototypeOf(async function() {
+      }).constructor;
       function efn() {
         return "";
       }
@@ -3850,6 +4186,45 @@
           }
         });
       };
+      function buildExtendsDeferred(tokens, options) {
+        var childBlocks = {};
+        var childIRs = [];
+        utils.each(tokens.blocks, function(blockToken) {
+          var args = blockToken.args ? blockToken.args.slice(0) : [];
+          var content = blockToken.content ? blockToken.content.slice(0) : [];
+          if (blockToken.name === "block") {
+            var blockName = args.join("");
+            var blockIR = blockToken.compile(backend.compile, args, content, [], options, blockName, blockToken);
+            if (blockIR && typeof blockIR === "object" && typeof blockIR.type === "string") {
+              childBlocks[blockName] = blockIR;
+            }
+            return;
+          }
+          var result = blockToken.compile(backend.compile, args, content, [], options, void 0, blockToken);
+          if (result === void 0 || result === null || result === "") {
+            return;
+          }
+          if (typeof result === "string") {
+            childIRs.push(ir.legacyJS(result));
+            return;
+          }
+          if (utils.isArray(result)) {
+            utils.each(result, function(n) {
+              childIRs.push(n);
+            });
+            return;
+          }
+          if (typeof result === "object" && typeof result.type === "string") {
+            childIRs.push(result);
+          }
+        });
+        return ir.extendsDeferred(
+          ir.literal("string", tokens.parent),
+          childBlocks,
+          childIRs,
+          options.filename || ""
+        );
+      }
       exports.getParents = function(tokens, options, deps) {
         var parentName = tokens.parent, parentFiles = [], parents = [], parentFile, parent, l;
         while (parentName) {
@@ -3874,14 +4249,12 @@
         return parents;
       };
       exports.buildTemplateFunction = function(tokens, parents, options) {
-        return new Function(
-          "_swig",
-          "_ctx",
-          "_filters",
-          "_utils",
-          "_fn",
-          '  var _ext = _swig.extensions,\n    _output = "";\n' + backend.compile(tokens, parents, options) + "\n  return _output;\n"
-        );
+        if (options && options.codegenMode === "async") {
+          var asyncBody = '  var _ext = _swig.extensions,\n    _output = "",\n    _exports = {};\n' + backend.compile(tokens, parents, options) + "\n  return { output: _output, exports: _exports };\n";
+          return new AsyncFunction("_swig", "_ctx", "_filters", "_utils", "_fn", "_blocks", asyncBody);
+        }
+        var body = '  var _ext = _swig.extensions,\n    _output = "";\n' + backend.compile(tokens, parents, options) + "\n  return _output;\n";
+        return new Function("_swig", "_ctx", "_filters", "_utils", "_fn", body);
       };
       exports.install = function(self, frontend) {
         var parser = frontend.parser, tags = utils.extend({}, frontend.tags), filters = utils.extend({}, frontend.filters), validateOptions = frontend.validateOptions, onCompileError = frontend.onCompileError;
@@ -3959,10 +4332,16 @@
           return self.parse(src, options);
         };
         self.precompile = function(source, options) {
-          var tokens = self.parse(source, options), parents = getParentsInternal(tokens, options), tpl;
-          if (parents.length) {
-            tokens.tokens = exports.remapBlocks(tokens.blocks, parents[0].tokens);
-            exports.importNonBlocks(tokens.blocks, tokens.tokens);
+          var tokens = self.parse(source, options), parents, tpl;
+          if (options && options.codegenMode === "async" && tokens.parent) {
+            parents = [];
+            tokens.tokens = [buildExtendsDeferred(tokens, options)];
+          } else {
+            parents = getParentsInternal(tokens, options);
+            if (parents.length) {
+              tokens.tokens = exports.remapBlocks(tokens.blocks, parents[0].tokens);
+              exports.importNonBlocks(tokens.blocks, tokens.tokens);
+            }
           }
           try {
             tpl = exports.buildTemplateFunction(tokens, parents, options);
@@ -3979,7 +4358,7 @@
           context = getLocals(options);
           contextLength = utils.keys(context).length;
           pre = self.precompile(source, options);
-          function compiled(locals) {
+          function compiled(locals, blocks) {
             var lcls;
             if (locals && contextLength) {
               lcls = utils.extend({}, context, locals);
@@ -3990,7 +4369,7 @@
             } else {
               lcls = {};
             }
-            return pre.tpl(self, lcls, filters, utils, efn);
+            return pre.tpl(self, lcls, filters, utils, efn, blocks);
           }
           utils.extend(compiled, pre.tokens);
           if (key) {
@@ -4035,11 +4414,65 @@
           src = self.options.loader.load(pathname);
           return self.compile(src, options);
         };
+        self.getTemplate = function(pathname, options) {
+          options = options || {};
+          var resolved;
+          try {
+            resolved = self.options.loader.resolve(pathname, options.resolveFrom);
+          } catch (e) {
+            return Promise.reject(e);
+          }
+          var compileOpts = utils.extend({}, options, {
+            filename: options.filename || resolved,
+            codegenMode: "async",
+            cache: false
+          });
+          return new Promise(function(resolve, reject) {
+            function onLoaded(err, src2) {
+              if (err) {
+                reject(err);
+                return;
+              }
+              var compiled;
+              try {
+                compiled = self.compile(src2, compileOpts);
+              } catch (err2) {
+                reject(err2);
+                return;
+              }
+              resolve(compiled);
+            }
+            if (self.options.loader.load.length >= 2) {
+              try {
+                self.options.loader.load(resolved, onLoaded);
+              } catch (e) {
+                onLoaded(e);
+              }
+            } else {
+              var src;
+              try {
+                src = self.options.loader.load(resolved);
+              } catch (e) {
+                onLoaded(e);
+                return;
+              }
+              onLoaded(null, src);
+            }
+          });
+        };
         self.render = function(source, options) {
           return self.compile(source, options)();
         };
         self.renderFile = function(pathName, locals, cb) {
           if (cb) {
+            if (self.options.loader && self.options.loader.async === true) {
+              self.getTemplate(pathName).then(function(fn) {
+                return fn(locals);
+              }).then(function(result) {
+                cb(null, result.output);
+              }).catch(cb);
+              return;
+            }
             self.compileFile(pathName, {}, function(err, fn) {
               var result;
               if (err) {
@@ -4078,8 +4511,9 @@
       var parser = require_parser();
       var dateformatter = require_dateformatter2();
       var loaders = require_loaders2();
+      var preWalker = require_pre_walker();
       var engine = require_engine();
-      exports.version = "2.0.1";
+      exports.version = "2.2.0";
       var defaultOptions = {
         autoescape: true,
         varControls: ["{{", "}}"],
@@ -4182,6 +4616,94 @@
             utils.throwError(err, null, options.filename);
           }
         });
+        var self = this;
+        function buildScanOpts() {
+          return {
+            varControls: self.options.varControls,
+            tagControls: self.options.tagControls,
+            cmtControls: self.options.cmtControls,
+            rawTag: "raw",
+            keywords: ["extends", "include", "import"]
+          };
+        }
+        this.renderFileAsync = function(pathName, locals, cb) {
+          if (typeof locals === "function") {
+            cb = locals;
+            locals = void 0;
+          }
+          var loader = self.options.loader;
+          var entry;
+          try {
+            entry = loader.resolve(pathName);
+          } catch (e) {
+            cb(e);
+            return;
+          }
+          preWalker.walk(entry, loader, buildScanOpts()).then(function(memMap) {
+            var memWrapper = preWalker.makeMemoryWrapper(loader, memMap);
+            var origLoader = self.options.loader;
+            self.options.loader = memWrapper;
+            var output, error;
+            try {
+              output = self.renderFile(entry, locals);
+            } catch (e) {
+              error = e;
+            }
+            self.options.loader = origLoader;
+            if (error) {
+              cb(error);
+              return;
+            }
+            cb(null, output);
+          }, function(err) {
+            cb(err);
+          });
+        };
+        this.compileFileAsync = function(pathName, options, cb) {
+          if (typeof options === "function") {
+            cb = options;
+            options = {};
+          }
+          var loader = self.options.loader;
+          var entry;
+          try {
+            entry = loader.resolve(pathName);
+          } catch (e) {
+            cb(e);
+            return;
+          }
+          preWalker.walk(entry, loader, buildScanOpts()).then(function(memMap) {
+            var memWrapper = preWalker.makeMemoryWrapper(loader, memMap);
+            var origLoader = self.options.loader;
+            self.options.loader = memWrapper;
+            var compiled, error;
+            try {
+              compiled = self.compileFile(entry, options);
+            } catch (e) {
+              error = e;
+            }
+            self.options.loader = origLoader;
+            if (error) {
+              cb(error);
+              return;
+            }
+            var wrapped = function(locals) {
+              var origInner = self.options.loader;
+              self.options.loader = memWrapper;
+              try {
+                var output = compiled(locals);
+                self.options.loader = origInner;
+                return output;
+              } catch (e) {
+                self.options.loader = origInner;
+                throw e;
+              }
+            };
+            cb(null, wrapped);
+          }, function(err) {
+            cb(err);
+          });
+        };
       };
       defaultInstance = new exports.Swig();
       exports.setFilter = defaultInstance.setFilter;
@@ -4191,8 +4713,10 @@
       exports.precompile = defaultInstance.precompile;
       exports.compile = defaultInstance.compile;
       exports.compileFile = defaultInstance.compileFile;
+      exports.compileFileAsync = defaultInstance.compileFileAsync;
       exports.render = defaultInstance.render;
       exports.renderFile = defaultInstance.renderFile;
+      exports.renderFileAsync = defaultInstance.renderFileAsync;
       exports.run = defaultInstance.run;
       exports.invalidateCache = defaultInstance.invalidateCache;
       exports.loaders = loaders;
@@ -4273,10 +4797,13 @@
  * compiled VarRef body relies on. @private
  */
 /*!
- * Replica of `TokenParser.prototype.checkMatch`. Kept as a local private
- * helper rather than imported from tokenparser.js because (a) it is a
- * pure function of its argument and (b) the backend must not acquire a
- * runtime dependency on the TokenParser module (which is a specific
+ * Build the dot-path emit. `(checkDot_ctx ? _ctx.<path> : (checkDot_closure
+ * ? <path> : ""))` — checks the `_ctx.<path>` walk first, falls back to a
+ * bare-closure walk (covers macro params, host-globals like `Math`), and
+ * coerces a missing path to `""` for safe interpolation. Kept as a local
+ * private helper rather than imported from tokenparser.js because (a) it
+ * is a pure function of its argument and (b) the backend must not acquire
+ * a runtime dependency on the TokenParser module (which is a specific
  * frontend concern, not a shared-backend one). @private
  */
 /*!
@@ -4316,6 +4843,21 @@
  * Loop over the source, split via the tag/var/comment regular expression splitter.
  * Send each chunk to the appropriate parser.
  */
+/*!
+ * Makes a string safe for a regular expression. Mirrors lib/parser.js.
+ * @private
+ */
+/*!
+ * Build the splitter regex from the controls trio. Mirrors the regex that
+ * parser.parse() builds at parse-time so the pre-walker chunks the same
+ * way the real parser would.
+ * @private
+ */
+/*!
+ * Strip tag controls and optional whitespace-control markers from a tag
+ * chunk, returning the trimmed tag body (e.g. `extends "x.html"`).
+ * @private
+ */
 /*!
  * Export methods publicly
  */