{"version":3,"sources":["../webpack/universalModuleDefinition","../webpack/bootstrap 679ff8296d850238baf3","../nunjucks/src/lib.js","../nunjucks/src/object.js","../nunjucks/src/runtime.js","../nunjucks/src/nodes.js","../nunjucks/src/compiler.js","../nunjucks/src/loader.js","../nunjucks/src/environment.js","../nunjucks/src/parser.js","../nunjucks/src/lexer.js","../nunjucks/src/web-loaders.js","../nunjucks/index.js","../node_modules/asap/browser-asap.js","../node_modules/asap/browser-raw.js","../node_modules/webpack/buildin/global.js","../node_modules/a-sync-waterfall/index.js","../node_modules/webpack/node_modules/events/events.js","../nunjucks/src/transformer.js","../nunjucks/src/filters.js","../nunjucks/src/precompiled-loader.js","../nunjucks/src/tests.js","../nunjucks/src/globals.js","../nunjucks/src/express-app.js","../nunjucks/src/precompile.js","../nunjucks/src/precompile-global.js","../nunjucks/src/jinja-compat.js"],"names":["ArrayProto","Array","prototype","ObjProto","Object","escapeMap","escapeRegex","exports","module","hasOwnProp","obj","k","hasOwnProperty","call","lookupEscape","ch","_prettifyError","path","withInternals","err","Update","TemplateError","old","Error","message","name","lineno","colno","cause","setPrototypeOf","defineProperty","enumerable","writable","value","captureStackTrace","constructor","getStack","stackDescriptor","getOwnPropertyDescriptor","get","stack","firstUpdate","msg","create","escape","val","replace","isFunction","toString","isArray","isString","isObject","_prepareAttributeParts","attr","split","getAttrGetter","attribute","parts","attrGetter","item","_item","i","length","part","undefined","groupBy","throwOnUndefined","result","iterator","key","TypeError","push","toArray","slice","without","array","contains","arguments","index","indexOf","repeat","char_","n","str","each","func","context","forEach","l","map","results","asyncIter","arr","iter","cb","next","asyncFor","keys","keys_","len","searchElement","fromIndex","_entries","_values","extend","obj1","obj2","_assign","inOperator","EventEmitter","require","lib","parentWrap","parent","prop","wrap","tmp","res","apply","extendClass","cls","props","subclass","Obj","init","EmitterObj","arrayFrom","from","supportsIterators","Symbol","Frame","isolateWrites","variables","topLevel","set","resolveUp","frame","resolve","id","lookup","p","forWrite","pop","makeMacro","argNames","kwargNames","macro","macroArgs","argCount","numArgs","args","kwargs","getKeywordArgs","arg","makeKeywordArgs","__keywords","isKeywordArgs","lastArg","SafeString","String","configurable","valueOf","copySafeness","dest","target","markSafe","type","wrapSafe","ret","suppressValue","autoescape","ensureDefined","memberLookup","callWrap","contextOrFrameLookup","handleError","error","asyncEach","dimen","iterCallback","asyncAll","finished","outputArr","done","output","join","fromIterator","traverseAndCheck","Node","findAll","fields","field","NodeList","children","child","iterFields","Value","nodes","addChild","node","Root","Literal","Group","ArrayNode","Pair","Dict","LookupVal","If","IfAsync","InlineIf","For","AsyncEach","AsyncAll","Macro","Caller","Import","FromImport","template","names","withContext","FunCall","Filter","FilterAsync","KeywordArgs","Block","Super","TemplateRef","Extends","Include","Set","Switch","Case","Output","Capture","TemplateData","UnaryOp","BinOp","In","Is","Or","And","Not","Add","Concat","Sub","Mul","Div","FloorDiv","Mod","Pow","Neg","Pos","Compare","CompareOperand","CallExtension","ext","contentArgs","extName","__name","CallExtensionAsync","print","indent","inline","lines","line","process","stdout","write","nl","printNodes","typename","fieldName","JSON","stringify","parser","transformer","compareOps","Compiler","templateName","codebuf","lastId","buffer","bufferStack","_scopeClosers","inBlock","fail","_pushBuffer","_tmpid","_emit","_popBuffer","code","_emitLine","_emitLines","_emitFuncBegin","_emitFuncEnd","noReturn","_closeScopeLevels","_addScopeLevel","_withScopedSyntax","_makeCallback","_templateName","_compileChildren","compile","_compileAggregate","startChar","endChar","_compileExpression","assertType","types","some","t","compileCallExtension","async","compileCallExtensionAsync","compileNodeList","compileLiteral","compileSymbol","v","compileGroup","compileArray","compileDict","compilePair","compileInlineIf","cond","body","else_","compileIn","left","right","compileIs","_binOpEmitter","compileOr","compileAnd","compileAdd","compileConcat","compileSub","compileMul","compileDiv","compileMod","compileNot","compileFloorDiv","compilePow","compileNeg","compilePos","compileCompare","expr","ops","op","compileLookupVal","_getNodeName","compileFunCall","compileFilter","compileFilterAsync","symbol","compileKeywordArgs","compileSet","ids","targets","charAt","compileSwitch","cases","c","default","compileIf","compileIfAsync","_emitLoopBindings","bindings","b","compileFor","u","tid","_compileAsyncLoop","parallel","asyncMethod","arrayLen","buf","compileAsyncEach","compileAsyncAll","_compileMacro","funcId","keepFrame","realNames","currFrame","pair","bufferId","compileMacro","compileCaller","_compileGetTemplate","eagerCompile","ignoreMissing","parentTemplateId","parentName","eagerCompileArg","ignoreMissingArg","compileImport","compileFromImport","importedId","nameNode","alias","compileBlock","compileSuper","blockName","compileExtends","compileInclude","id2","compileTemplateData","compileCapture","compileOutput","compileRoot","blockNames","blocks","block","tmpFrame","_compile","getCode","src","asyncFilters","extensions","opts","preprocessors","preprocess","filter","f","processedSrc","reduce","s","processor","transform","parse","to","dirname","isRelative","filename","asap","waterfall","compiler","filters","FileSystemLoader","WebLoader","PrecompiledLoader","tests","globals","globalRuntime","expressApp","callbackAsap","noopTmplSrc","root","env","runtime","e","Environment","loaders","dev","trimBlocks","lstripBlocks","window","nunjucksPrecompiled","unshift","_initLoaders","extensionsList","addFilter","test","addTest","loader","cache","on","fullname","emit","source","invalidateCache","addExtension","extension","removeExtension","getExtension","hasExtension","addGlobal","getGlobal","wrapped","getFilter","getTest","resolveTemplate","getTemplate","that","tmpl","raw","Template","syncResult","createTemplate","info","newTmpl","noCache","handle","getSource","express","app","render","ctx","renderString","tasks","callback","forceAsync","Context","exported","addBlock","setVariable","getVariables","getBlock","getSuper","idx","blk","addExport","getExported","tmplProps","tmplStr","compiled","parentFrame","didError","rootRenderFunc","Function","_getBlocks","lexer","Parser","tokens","peeked","breakOnBlocks","dropLeadingWhitespace","nextToken","withWhitespace","tok","TOKEN_WHITESPACE","peekToken","pushToken","skip","expect","skipValue","skipSymbol","TOKEN_SYMBOL","advanceAfterBlockEnd","TOKEN_BLOCK_END","advanceAfterVariableEnd","TOKEN_VARIABLE_END","tags","VARIABLE_END","parseFor","forTok","endBlock","parsePrimary","TOKEN_COMMA","prim","parseExpression","parseUntilBlocks","parseMacro","macroTok","parseSignature","parseCall","callTok","callerArgs","macroCall","callerName","callerNode","parseWithContext","parseImport","importTok","parseFrom","fromTok","nextTok","parseBlock","tag","parseExtends","tagName","parseInclude","parseIf","parseSet","TOKEN_OPERATOR","parseSwitch","switchStart","switchEnd","caseStart","caseDefault","defaultCase","col","parseStatement","parseRaw","parseFilterStatement","endTagName","rawBlockRegex","RegExp","rawLevel","matches","begun","_extractRegex","all","pre","backN","parsePostfix","TOKEN_LEFT_PAREN","TOKEN_LEFT_BRACKET","parseAggregate","parseInlineIf","parseOr","condNode","bodyNode","parseAnd","node2","parseNot","parseIn","parseIs","invert","parseCompare","not","parseConcat","parseAdd","TOKEN_TILDE","parseSub","parseMul","parseDiv","parseFloorDiv","parseMod","parsePow","parseUnary","noFilters","parseFilter","noPostfix","TOKEN_STRING","TOKEN_INT","parseInt","TOKEN_FLOAT","parseFloat","TOKEN_BOOLEAN","TOKEN_NONE","TOKEN_REGEX","flags","parseFilterName","parseFilterArgs","TOKEN_PIPE","concat","filterTok","TOKEN_LEFT_CURLY","TOKEN_RIGHT_PAREN","TOKEN_RIGHT_BRACKET","TOKEN_RIGHT_CURLY","TOKEN_COLON","tolerant","noParens","checkComma","prev","parseNodes","TOKEN_DATA","data","nextVal","TOKEN_BLOCK_START","TOKEN_VARIABLE_START","VARIABLE_START","TOKEN_COMMENT","COMMENT_START","COMMENT_END","parseAsRoot","lex","whitespaceChars","delimChars","intChars","BLOCK_START","BLOCK_END","TOKEN_SPECIAL","token","Tokenizer","in_code","blockStart","blockEnd","variableStart","variableEnd","commentStart","commentEnd","cur","current","isFinished","_parseString","_extract","_extractString","forward","back","forwardN","regexBody","previous","POSSIBLE_FLAGS","regexFlags","isCurrentAFlag","complexOps","curComplex","_extractUntil","match","dec","beginChars","inComment","_matches","lastLine","delimiter","m","charString","_extractMatching","breakOnMatch","first","regex","currentStr","lastIndexOf","substr","Loader","baseURL","useCache","fetch","content","status","url","ajax","XMLHttpRequest","loading","onreadystatechange","readyState","responseText","Date","getTime","open","send","precompile","installJinjaCompat","configure","templatesPath","TemplateLoader","watch","web","NodeResolveLoader","reset","precompileString","sym","gensym","mapCOW","walk","ast","depthFirst","astT","propsT","depthWalk","_liftFilters","walked","descNode","liftFilters","liftSuper","blockNode","hasSuper","convertStatements","cps","r","normalize","defaultValue","abs","Math","isNaN","num","batch","linecount","fillWith","capitalize","toLowerCase","toUpperCase","center","width","spaces","post","default_","def","bool","dictsort","caseSensitive","by","si","sort","t1","t2","a","dump","safe","forceescape","groupby","indentfirst","sp","del","last","lengthFilter","Map","size","list","lower","nl2br","random","floor","getSelectOrReject","expectedTestResult","testName","secondArg","examineTestResult","reject","rejectattr","select","selectattr","new_","maxCount","originalStr","nextIndex","pos","count","substring","reverse","round","precision","method","factor","pow","rounder","ceil","slices","sliceLength","extra","offset","start","end","currSlice","sum","sortFilter","reversed","caseSens","getAttribute","x","y","string","striptags","input","preserveLinebreaks","trimmedInput","trim","title","words","word","truncate","killwords","orig","upper","urlencode","enc","encodeURIComponent","keyvals","puncRe","emailRe","httpHttpsRe","wwwRe","tldRe","urlize","nofollow","Infinity","noFollowAttr","possibleUrl","shortUrl","wordcount","float","intFilter","doInt","base","int","d","compiledTemplates","precompiled","callable","defined","divisibleby","one","two","escaped","equalto","eq","sameas","even","falsy","ge","greaterthan","gt","le","lessthan","lt","ne","nullTest","null","number","odd","truthy","undefinedTest","iterable","mapping","cycler","items","joiner","sep","range","stop","step","NunjucksView","defaultEngine","extname","fs","precompileGlobal","patterns","pattern","wrapper","_precompile","pathStats","existsSync","statSync","templates","addTemplates","dir","readdirSync","file","filepath","subpath","stat","isDirectory","exclude","include","isFile","readFileSync","force","console","out","asFunction","installCompat","orig_contextOrFrameLookup","orig_memberLookup","orig_Compiler_assertType","orig_Parser_parseAggregate","uninstall","getTokensState","Slice","compileSlice","origState","errState","rethrow","isSlice","sliceLookup","ARRAY_MEMBERS","splice","append","element","remove","find","insert","elem","OBJECT_MEMBERS","values","has_key","popitem","setdefault","update","iteritems","itervalues","iterkeys","bind"],"mappings":"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BAA1B,GAA6C5pB;AAxChD,CAAjB,C;;;;;;;AC9Ca;;AAEb;AACA,cAAc,mBAAO,CAAC,EAAO;AAC7B;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,YAAY,MAAM;AAClB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;;;;;;;;ACjEA,8CAAa;;AAEb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gEAAgE,kBAAkB;AAClF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,oBAAoB;AAChD;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;;;;;;;AC9NA;;AAEA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;;AAEA;AACA;AACA,4CAA4C;;AAE5C;;;;;;;ACpBA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;AACL;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA;AACA;;AAEA,MAAM,IAA2C;AACjD,IAAI,iCAAO,EAAE,mCAAE;AACf;AACA,KAAK;AAAA,oGAAC,CAAC;AACP,GAAG;AACH,+BAA+B;AAC/B,GAAG;AACH,kCAAkC;AAClC;AACA,CAAC;;;;;;;;AClFD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEa;;AAEb;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,iBAAiB,sBAAsB;AACvC;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe;AACf;AACA;AACA;AACA;AACA,cAAc;AACd;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA,GAAG;AACH;AACA;AACA,mBAAmB,SAAS;AAC5B;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA,KAAK;AACL;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,eAAe;AACf;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;;AAEA,iCAAiC,QAAQ;AACzC;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,mBAAmB,iBAAiB;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA,OAAO;AACP;AACA,sCAAsC,QAAQ;AAC9C;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,iBAAiB,OAAO;AACxB;AACA;AACA;;AAEA;AACA,QAAQ,yBAAyB;AACjC;AACA;AACA;;AAEA;AACA;AACA,iBAAiB,gBAAgB;AACjC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA,GAAG;AACH;;;;;;;;AC3da;;AAEb,IAAIqI,KAAK,GAAGvF,mBAAO,CAAC,CAAD,CAAnB;;AACA,IAAIC,GAAG,GAAGD,mBAAO,CAAC,CAAD,CAAjB;;AAEA,IAAI+mB,GAAG,GAAG,CAAV;;AACA,SAASC,MAAT,GAAkB;AAChB,SAAO,UAAUD,GAAG,EAApB;AACD,C,CAED;;;AACA,SAASE,MAAT,CAAgBnoB,GAAhB,EAAqBP,IAArB,EAA2B;AACzB,MAAIgC,GAAG,GAAG,IAAV;;AACA,OAAK,IAAIxD,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG+B,GAAG,CAAC9B,MAAxB,EAAgCD,CAAC,EAAjC,EAAqC;AACnC,QAAMF,IAAI,GAAG0B,IAAI,CAACO,GAAG,CAAC/B,CAAD,C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","file":"nunjucks.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"nunjucks\"] = factory();\n\telse\n\t\troot[\"nunjucks\"] = factory();\n})(typeof self !== 'undefined' ? self : this, function() {\nreturn \n\n\n// WEBPACK FOOTER //\n// webpack/universalModuleDefinition"," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, {\n \t\t\t\tconfigurable: false,\n \t\t\t\tenumerable: true,\n \t\t\t\tget: getter\n \t\t\t});\n \t\t}\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 11);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap 679ff8296d850238baf3","'use strict';\n\nvar ArrayProto = Array.prototype;\nvar ObjProto = Object.prototype;\n\nvar escapeMap = {\n  '&': '&amp;',\n  '\"': '&quot;',\n  '\\'': '&#39;',\n  '<': '&lt;',\n  '>': '&gt;'\n};\n\nvar escapeRegex = /[&\"'<>]/g;\n\nvar exports = module.exports = {};\n\nfunction hasOwnProp(obj, k) {\n  return ObjProto.hasOwnProperty.call(obj, k);\n}\n\nexports.hasOwnProp = hasOwnProp;\n\nfunction lookupEscape(ch) {\n  return escapeMap[ch];\n}\n\nfunction _prettifyError(path, withInternals, err) {\n  if (!err.Update) {\n    // not one of ours, cast it\n    err = new exports.TemplateError(err);\n  }\n  err.Update(path);\n\n  // Unless they marked the dev flag, show them a trace from here\n  if (!withInternals) {\n    const old = err;\n    err = new Error(old.message);\n    err.name = old.name;\n  }\n\n  return err;\n}\n\nexports._prettifyError = _prettifyError;\n\nfunction TemplateError(message, lineno, colno) {\n  var err;\n  var cause;\n\n  if (message instanceof Error) {\n    cause = message;\n    message = `${cause.name}: ${cause.message}`;\n  }\n\n  if (Object.setPrototypeOf) {\n    err = new Error(message);\n    Object.setPrototypeOf(err, TemplateError.prototype);\n  } else {\n    err = this;\n    Object.defineProperty(err, 'message', {\n      enumerable: false,\n      writable: true,\n      value: message,\n    });\n  }\n\n  Object.defineProperty(err, 'name', {\n    value: 'Template render error',\n  });\n\n  if (Error.captureStackTrace) {\n    Error.captureStackTrace(err, this.constructor);\n  }\n\n  let getStack;\n\n  if (cause) {\n    const stackDescriptor = Object.getOwnPropertyDescriptor(cause, 'stack');\n    getStack = stackDescriptor && (stackDescriptor.get || (() => stackDescriptor.value));\n    if (!getStack) {\n      getStack = () => cause.stack;\n    }\n  } else {\n    const stack = (new Error(message)).stack;\n    getStack = (() => stack);\n  }\n\n  Object.defineProperty(err, 'stack', {\n    get: () => getStack.call(err),\n  });\n\n  Object.defineProperty(err, 'cause', {\n    value: cause\n  });\n\n  err.lineno = lineno;\n  err.colno = colno;\n  err.firstUpdate = true;\n\n  err.Update = function Update(path) {\n    let msg = '(' + (path || 'unknown path') + ')';\n\n    // only show lineno + colno next to path of template\n    // where error occurred\n    if (this.firstUpdate) {\n      if (this.lineno && this.colno) {\n        msg += ` [Line ${this.lineno}, Column ${this.colno}]`;\n      } else if (this.lineno) {\n        msg += ` [Line ${this.lineno}]`;\n      }\n    }\n\n    msg += '\\n ';\n    if (this.firstUpdate) {\n      msg += ' ';\n    }\n\n    this.message = msg + (this.message || '');\n    this.firstUpdate = false;\n    return this;\n  };\n\n  return err;\n}\n\n\nif (Object.setPrototypeOf) {\n  Object.setPrototypeOf(TemplateError.prototype, Error.prototype);\n} else {\n  TemplateError.prototype = Object.create(Error.prototype, {\n    constructor: {\n      value: TemplateError,\n    },\n  });\n}\n\nexports.TemplateError = TemplateError;\n\nfunction escape(val) {\n  return val.replace(escapeRegex, lookupEscape);\n}\n\nexports.escape = escape;\n\nfunction isFunction(obj) {\n  return ObjProto.toString.call(obj) === '[object Function]';\n}\n\nexports.isFunction = isFunction;\n\nfunction isArray(obj) {\n  return ObjProto.toString.call(obj) === '[object Array]';\n}\n\nexports.isArray = isArray;\n\nfunction isString(obj) {\n  return ObjProto.toString.call(obj) === '[object String]';\n}\n\nexports.isString = isString;\n\nfunction isObject(obj) {\n  return ObjProto.toString.call(obj) === '[object Object]';\n}\n\nexports.isObject = isObject;\n\n/**\n * @param {string|number} attr\n * @returns {(string|number)[]}\n * @private\n */\nfunction _prepareAttributeParts(attr) {\n  if (!attr) {\n    return [];\n  }\n\n  if (typeof attr === 'string') {\n    return attr.split('.');\n  }\n\n  return [attr];\n}\n\n/**\n * @param {string}   attribute      Attribute value. Dots allowed.\n * @returns {function(Object): *}\n */\nfunction getAttrGetter(attribute) {\n  const parts = _prepareAttributeParts(attribute);\n\n  return function attrGetter(item) {\n    let _item = item;\n\n    for (let i = 0; i < parts.length; i++) {\n      const part = parts[i];\n\n      // If item is not an object, and we still got parts to handle, it means\n      // that something goes wrong. Just roll out to undefined in that case.\n      if (hasOwnProp(_item, part)) {\n        _item = _item[part];\n      } else {\n        return undefined;\n      }\n    }\n\n    return _item;\n  };\n}\n\nexports.getAttrGetter = getAttrGetter;\n\nfunction groupBy(obj, val, throwOnUndefined) {\n  const result = {};\n  const iterator = isFunction(val) ? val : getAttrGetter(val);\n  for (let i = 0; i < obj.length; i++) {\n    const value = obj[i];\n    const key = iterator(value, i);\n    if (key === undefined && throwOnUndefined === true) {\n      throw new TypeError(`groupby: attribute \"${val}\" resolved to undefined`);\n    }\n    (result[key] || (result[key] = [])).push(value);\n  }\n  return result;\n}\n\nexports.groupBy = groupBy;\n\nfunction toArray(obj) {\n  return Array.prototype.slice.call(obj);\n}\n\nexports.toArray = toArray;\n\nfunction without(array) {\n  const result = [];\n  if (!array) {\n    return result;\n  }\n  const length = array.length;\n  const contains = toArray(arguments).slice(1);\n  let index = -1;\n\n  while (++index < length) {\n    if (indexOf(contains, array[index]) === -1) {\n      result.push(array[index]);\n    }\n  }\n  return result;\n}\n\nexports.without = without;\n\nfunction repeat(char_, n) {\n  var str = '';\n  for (let i = 0; i < n; i++) {\n    str += char_;\n  }\n  return str;\n}\n\nexports.repeat = repeat;\n\nfunction each(obj, func, context) {\n  if (obj == null) {\n    return;\n  }\n\n  if (ArrayProto.forEach && obj.forEach === ArrayProto.forEach) {\n    obj.forEach(func, context);\n  } else if (obj.length === +obj.length) {\n    for (let i = 0, l = obj.length; i < l; i++) {\n      func.call(context, obj[i], i, obj);\n    }\n  }\n}\n\nexports.each = each;\n\nfunction map(obj, func) {\n  var results = [];\n  if (obj == null) {\n    return results;\n  }\n\n  if (ArrayProto.map && obj.map === ArrayProto.map) {\n    return obj.map(func);\n  }\n\n  for (let i = 0; i < obj.length; i++) {\n    results[results.length] = func(obj[i], i);\n  }\n\n  if (obj.length === +obj.length) {\n    results.length = obj.length;\n  }\n\n  return results;\n}\n\nexports.map = map;\n\nfunction asyncIter(arr, iter, cb) {\n  let i = -1;\n\n  function next() {\n    i++;\n\n    if (i < arr.length) {\n      iter(arr[i], i, next, cb);\n    } else {\n      cb();\n    }\n  }\n\n  next();\n}\n\nexports.asyncIter = asyncIter;\n\nfunction asyncFor(obj, iter, cb) {\n  const keys = keys_(obj || {});\n  const len = keys.length;\n  let i = -1;\n\n  function next() {\n    i++;\n    const k = keys[i];\n\n    if (i < len) {\n      iter(k, obj[k], i, len, next);\n    } else {\n      cb();\n    }\n  }\n\n  next();\n}\n\nexports.asyncFor = asyncFor;\n\nfunction indexOf(arr, searchElement, fromIndex) {\n  return Array.prototype.indexOf.call(arr || [], searchElement, fromIndex);\n}\n\nexports.indexOf = indexOf;\n\nfunction keys_(obj) {\n  /* eslint-disable no-restricted-syntax */\n  const arr = [];\n  for (let k in obj) {\n    if (hasOwnProp(obj, k)) {\n      arr.push(k);\n    }\n  }\n  return arr;\n}\n\nexports.keys = keys_;\n\nfunction _entries(obj) {\n  return keys_(obj).map((k) => [k, obj[k]]);\n}\n\nexports._entries = _entries;\n\nfunction _values(obj) {\n  return keys_(obj).map((k) => obj[k]);\n}\n\nexports._values = _values;\n\nfunction extend(obj1, obj2) {\n  obj1 = obj1 || {};\n  keys_(obj2).forEach(k => {\n    obj1[k] = obj2[k];\n  });\n  return obj1;\n}\n\nexports._assign = exports.extend = extend;\n\nfunction inOperator(key, val) {\n  if (isArray(val) || isString(val)) {\n    return val.indexOf(key) !== -1;\n  } else if (isObject(val)) {\n    return key in val;\n  }\n  throw new Error('Cannot use \"in\" operator to search for \"'\n    + key + '\" in unexpected types.');\n}\n\nexports.inOperator = inOperator;\n\n\n\n// WEBPACK FOOTER //\n// ./nunjucks/src/lib.js","'use strict';\n\n// A simple class system, more documentation to come\nconst EventEmitter = require('events');\nconst lib = require('./lib');\n\nfunction parentWrap(parent, prop) {\n  if (typeof parent !== 'function' || typeof prop !== 'function') {\n    return prop;\n  }\n  return function wrap() {\n    // Save the current parent method\n    const tmp = this.parent;\n\n    // Set parent to the previous method, call, and restore\n    this.parent = parent;\n    const res = prop.apply(this, arguments);\n    this.parent = tmp;\n\n    return res;\n  };\n}\n\nfunction extendClass(cls, name, props) {\n  props = props || {};\n\n  lib.keys(props).forEach(k => {\n    props[k] = parentWrap(cls.prototype[k], props[k]);\n  });\n\n  class subclass extends cls {\n    get typename() {\n      return name;\n    }\n  }\n\n  lib._assign(subclass.prototype, props);\n\n  return subclass;\n}\n\nclass Obj {\n  constructor(...args) {\n    // Unfortunately necessary for backwards compatibility\n    this.init(...args);\n  }\n\n  init() {}\n\n  get typename() {\n    return this.constructor.name;\n  }\n\n  static extend(name, props) {\n    if (typeof name === 'object') {\n      props = name;\n      name = 'anonymous';\n    }\n    return extendClass(this, name, props);\n  }\n}\n\nclass EmitterObj extends EventEmitter {\n  constructor(...args) {\n    super();\n    // Unfortunately necessary for backwards compatibility\n    this.init(...args);\n  }\n\n  init() {}\n\n  get typename() {\n    return this.constructor.name;\n  }\n\n  static extend(name, props) {\n    if (typeof name === 'object') {\n      props = name;\n      name = 'anonymous';\n    }\n    return extendClass(this, name, props);\n  }\n}\n\nmodule.exports = { Obj, EmitterObj };\n\n\n\n// WEBPACK FOOTER //\n// ./nunjucks/src/object.js","'use strict';\n\nvar lib = require('./lib');\nvar arrayFrom = Array.from;\nvar supportsIterators = (\n  typeof Symbol === 'function' && Symbol.iterator && typeof arrayFrom === 'function'\n);\n\n\n// Frames keep track of scoping both at compile-time and run-time so\n// we know how to access variables. Block tags can introduce special\n// variables, for example.\nclass Frame {\n  constructor(parent, isolateWrites) {\n    this.variables = Object.create(null);\n    this.parent = parent;\n    this.topLevel = false;\n    // if this is true, writes (set) should never propagate upwards past\n    // this frame to its parent (though reads may).\n    this.isolateWrites = isolateWrites;\n  }\n\n  set(name, val, resolveUp) {\n    // Allow variables with dots by automatically creating the\n    // nested structure\n    var parts = name.split('.');\n    var obj = this.variables;\n    var frame = this;\n\n    if (resolveUp) {\n      if ((frame = this.resolve(parts[0], true))) {\n        frame.set(name, val);\n        return;\n      }\n    }\n\n    for (let i = 0; i < parts.length - 1; i++) {\n      const id = parts[i];\n\n      if (!obj[id]) {\n        obj[id] = {};\n      }\n      obj = obj[id];\n    }\n\n    obj[parts[parts.length - 1]] = val;\n  }\n\n  get(name) {\n    var val = this.variables[name];\n    if (val !== undefined) {\n      return val;\n    }\n    return null;\n  }\n\n  lookup(name) {\n    var p = this.parent;\n    var val = this.variables[name];\n    if (val !== undefined) {\n      return val;\n    }\n    return p && p.lookup(name);\n  }\n\n  resolve(name, forWrite) {\n    var p = (forWrite && this.isolateWrites) ? undefined : this.parent;\n    var val = this.variables[name];\n    if (val !== undefined) {\n      return this;\n    }\n    return p && p.resolve(name);\n  }\n\n  push(isolateWrites) {\n    return new Frame(this, isolateWrites);\n  }\n\n  pop() {\n    return this.parent;\n  }\n}\n\nfunction makeMacro(argNames, kwargNames, func) {\n  return function macro(...macroArgs) {\n    var argCount = numArgs(macroArgs);\n    var args;\n    var kwargs = getKeywordArgs(macroArgs);\n\n    if (argCount > argNames.length) {\n      args = macroArgs.slice(0, argNames.length);\n\n      // Positional arguments that should be passed in as\n      // keyword arguments (essentially default values)\n      macroArgs.slice(args.length, argCount).forEach((val, i) => {\n        if (i < kwargNames.length) {\n          kwargs[kwargNames[i]] = val;\n        }\n      });\n      args.push(kwargs);\n    } else if (argCount < argNames.length) {\n      args = macroArgs.slice(0, argCount);\n\n      for (let i = argCount; i < argNames.length; i++) {\n        const arg = argNames[i];\n\n        // Keyword arguments that should be passed as\n        // positional arguments, i.e. the caller explicitly\n        // used the name of a positional arg\n        args.push(kwargs[arg]);\n        delete kwargs[arg];\n      }\n      args.push(kwargs);\n    } else {\n      args = macroArgs;\n    }\n\n    return func.apply(this, args);\n  };\n}\n\nfunction makeKeywordArgs(obj) {\n  obj.__keywords = true;\n  return obj;\n}\n\nfunction isKeywordArgs(obj) {\n  return obj && Object.prototype.hasOwnProperty.call(obj, '__keywords');\n}\n\nfunction getKeywordArgs(args) {\n  var len = args.length;\n  if (len) {\n    const lastArg = args[len - 1];\n    if (isKeywordArgs(lastArg)) {\n      return lastArg;\n    }\n  }\n  return {};\n}\n\nfunction numArgs(args) {\n  var len = args.length;\n  if (len === 0) {\n    return 0;\n  }\n\n  const lastArg = args[len - 1];\n  if (isKeywordArgs(lastArg)) {\n    return len - 1;\n  } else {\n    return len;\n  }\n}\n\n// A SafeString object indicates that the string should not be\n// autoescaped. This happens magically because autoescaping only\n// occurs on primitive string objects.\nfunction SafeString(val) {\n  if (typeof val !== 'string') {\n    return val;\n  }\n\n  this.val = val;\n  this.length = val.length;\n}\n\nSafeString.prototype = Object.create(String.prototype, {\n  length: {\n    writable: true,\n    configurable: true,\n    value: 0\n  }\n});\nSafeString.prototype.valueOf = function valueOf() {\n  return this.val;\n};\nSafeString.prototype.toString = function toString() {\n  return this.val;\n};\n\nfunction copySafeness(dest, target) {\n  if (dest instanceof SafeString) {\n    return new SafeString(target);\n  }\n  return target.toString();\n}\n\nfunction markSafe(val) {\n  var type = typeof val;\n\n  if (type === 'string') {\n    return new SafeString(val);\n  } else if (type !== 'function') {\n    return val;\n  } else {\n    return function wrapSafe(args) {\n      var ret = val.apply(this, arguments);\n\n      if (typeof ret === 'string') {\n        return new SafeString(ret);\n      }\n\n      return ret;\n    };\n  }\n}\n\nfunction suppressValue(val, autoescape) {\n  val = (val !== undefined && val !== null) ? val : '';\n\n  if (autoescape && !(val instanceof SafeString)) {\n    val = lib.escape(val.toString());\n  }\n\n  return val;\n}\n\nfunction ensureDefined(val, lineno, colno) {\n  if (val === null || val === undefined) {\n    throw new lib.TemplateError(\n      'attempted to output null or undefined value',\n      lineno + 1,\n      colno + 1\n    );\n  }\n  return val;\n}\n\nfunction memberLookup(obj, val) {\n  if (obj === undefined || obj === null) {\n    return undefined;\n  }\n\n  if (typeof obj[val] === 'function') {\n    return (...args) => obj[val].apply(obj, args);\n  }\n\n  return obj[val];\n}\n\nfunction callWrap(obj, name, context, args) {\n  if (!obj) {\n    throw new Error('Unable to call `' + name + '`, which is undefined or falsey');\n  } else if (typeof obj !== 'function') {\n    throw new Error('Unable to call `' + name + '`, which is not a function');\n  }\n\n  return obj.apply(context, args);\n}\n\nfunction contextOrFrameLookup(context, frame, name) {\n  var val = frame.lookup(name);\n  return (val !== undefined) ?\n    val :\n    context.lookup(name);\n}\n\nfunction handleError(error, lineno, colno) {\n  if (error.lineno) {\n    return error;\n  } else {\n    return new lib.TemplateError(error, lineno, colno);\n  }\n}\n\nfunction asyncEach(arr, dimen, iter, cb) {\n  if (lib.isArray(arr)) {\n    const len = arr.length;\n\n    lib.asyncIter(arr, function iterCallback(item, i, next) {\n      switch (dimen) {\n        case 1:\n          iter(item, i, len, next);\n          break;\n        case 2:\n          iter(item[0], item[1], i, len, next);\n          break;\n        case 3:\n          iter(item[0], item[1], item[2], i, len, next);\n          break;\n        default:\n          item.push(i, len, next);\n          iter.apply(this, item);\n      }\n    }, cb);\n  } else {\n    lib.asyncFor(arr, function iterCallback(key, val, i, len, next) {\n      iter(key, val, i, len, next);\n    }, cb);\n  }\n}\n\nfunction asyncAll(arr, dimen, func, cb) {\n  var finished = 0;\n  var len;\n  var outputArr;\n\n  function done(i, output) {\n    finished++;\n    outputArr[i] = output;\n\n    if (finished === len) {\n      cb(null, outputArr.join(''));\n    }\n  }\n\n  if (lib.isArray(arr)) {\n    len = arr.length;\n    outputArr = new Array(len);\n\n    if (len === 0) {\n      cb(null, '');\n    } else {\n      for (let i = 0; i < arr.length; i++) {\n        const item = arr[i];\n\n        switch (dimen) {\n          case 1:\n            func(item, i, len, done);\n            break;\n          case 2:\n            func(item[0], item[1], i, len, done);\n            break;\n          case 3:\n            func(item[0], item[1], item[2], i, len, done);\n            break;\n          default:\n            item.push(i, len, done);\n            func.apply(this, item);\n        }\n      }\n    }\n  } else {\n    const keys = lib.keys(arr || {});\n    len = keys.length;\n    outputArr = new Array(len);\n\n    if (len === 0) {\n      cb(null, '');\n    } else {\n      for (let i = 0; i < keys.length; i++) {\n        const k = keys[i];\n        func(k, arr[k], i, len, done);\n      }\n    }\n  }\n}\n\nfunction fromIterator(arr) {\n  if (typeof arr !== 'object' || arr === null || lib.isArray(arr)) {\n    return arr;\n  } else if (supportsIterators && Symbol.iterator in arr) {\n    return arrayFrom(arr);\n  } else {\n    return arr;\n  }\n}\n\nmodule.exports = {\n  Frame: Frame,\n  makeMacro: makeMacro,\n  makeKeywordArgs: makeKeywordArgs,\n  numArgs: numArgs,\n  suppressValue: suppressValue,\n  ensureDefined: ensureDefined,\n  memberLookup: memberLookup,\n  contextOrFrameLookup: contextOrFrameLookup,\n  callWrap: callWrap,\n  handleError: handleError,\n  isArray: lib.isArray,\n  keys: lib.keys,\n  SafeString: SafeString,\n  copySafeness: copySafeness,\n  markSafe: markSafe,\n  asyncEach: asyncEach,\n  asyncAll: asyncAll,\n  inOperator: lib.inOperator,\n  fromIterator: fromIterator\n};\n\n\n\n// WEBPACK FOOTER //\n// ./nunjucks/src/runtime.js","'use strict';\n\nconst {Obj} = require('./object');\n\nfunction traverseAndCheck(obj, type, results) {\n  if (obj instanceof type) {\n    results.push(obj);\n  }\n\n  if (obj instanceof Node) {\n    obj.findAll(type, results);\n  }\n}\n\nclass Node extends Obj {\n  init(lineno, colno, ...args) {\n    this.lineno = lineno;\n    this.colno = colno;\n\n    this.fields.forEach((field, i) => {\n      // The first two args are line/col numbers, so offset by 2\n      var val = arguments[i + 2];\n\n      // Fields should never be undefined, but null. It makes\n      // testing easier to normalize values.\n      if (val === undefined) {\n        val = null;\n      }\n\n      this[field] = val;\n    });\n  }\n\n  findAll(type, results) {\n    results = results || [];\n\n    if (this instanceof NodeList) {\n      this.children.forEach(child => traverseAndCheck(child, type, results));\n    } else {\n      this.fields.forEach(field => traverseAndCheck(this[field], type, results));\n    }\n\n    return results;\n  }\n\n  iterFields(func) {\n    this.fields.forEach((field) => {\n      func(this[field], field);\n    });\n  }\n}\n\n// Abstract nodes\nclass Value extends Node {\n  get typename() { return 'Value'; }\n  get fields() {\n    return ['value'];\n  }\n}\n\n// Concrete nodes\nclass NodeList extends Node {\n  get typename() { return 'NodeList'; }\n  get fields() { return ['children']; }\n\n  init(lineno, colno, nodes) {\n    super.init(lineno, colno, nodes || []);\n  }\n\n  addChild(node) {\n    this.children.push(node);\n  }\n}\n\nconst Root = NodeList.extend('Root');\nconst Literal = Value.extend('Literal');\nconst Symbol = Value.extend('Symbol');\nconst Group = NodeList.extend('Group');\nconst ArrayNode = NodeList.extend('Array');\nconst Pair = Node.extend('Pair', { fields: ['key', 'value'] });\nconst Dict = NodeList.extend('Dict');\nconst LookupVal = Node.extend('LookupVal', { fields: ['target', 'val'] });\nconst If = Node.extend('If', { fields: ['cond', 'body', 'else_'] });\nconst IfAsync = If.extend('IfAsync');\nconst InlineIf = Node.extend('InlineIf', { fields: ['cond', 'body', 'else_'] });\nconst For = Node.extend('For', { fields: ['arr', 'name', 'body', 'else_'] });\nconst AsyncEach = For.extend('AsyncEach');\nconst AsyncAll = For.extend('AsyncAll');\nconst Macro = Node.extend('Macro', { fields: ['name', 'args', 'body'] });\nconst Caller = Macro.extend('Caller');\nconst Import = Node.extend('Import', { fields: ['template', 'target', 'withContext'] });\n\nclass FromImport extends Node {\n  get typename() { return 'FromImport'; }\n  get fields() { return ['template', 'names', 'withContext']; }\n\n  init(lineno, colno, template, names, withContext) {\n    super.init(lineno, colno, template, names || new NodeList(), withContext);\n  }\n}\n\nconst FunCall = Node.extend('FunCall', { fields: ['name', 'args'] });\nconst Filter = FunCall.extend('Filter');\nconst FilterAsync = Filter.extend('FilterAsync', { fields: ['name', 'args', 'symbol'] });\nconst KeywordArgs = Dict.extend('KeywordArgs');\nconst Block = Node.extend('Block', { fields: ['name', 'body'] });\nconst Super = Node.extend('Super', { fields: ['blockName', 'symbol'] });\nconst TemplateRef = Node.extend('TemplateRef', { fields: ['template'] });\nconst Extends = TemplateRef.extend('Extends');\nconst Include = Node.extend('Include', { fields: ['template', 'ignoreMissing'] });\nconst Set = Node.extend('Set', { fields: ['targets', 'value'] });\nconst Switch = Node.extend('Switch', { fields: ['expr', 'cases', 'default'] });\nconst Case = Node.extend('Case', { fields: ['cond', 'body'] });\nconst Output = NodeList.extend('Output');\nconst Capture = Node.extend('Capture', { fields: ['body'] });\nconst TemplateData = Literal.extend('TemplateData');\nconst UnaryOp = Node.extend('UnaryOp', { fields: ['target'] });\nconst BinOp = Node.extend('BinOp', { fields: ['left', 'right'] });\nconst In = BinOp.extend('In');\nconst Is = BinOp.extend('Is');\nconst Or = BinOp.extend('Or');\nconst And = BinOp.extend('And');\nconst Not = UnaryOp.extend('Not');\nconst Add = BinOp.extend('Add');\nconst Concat = BinOp.extend('Concat');\nconst Sub = BinOp.extend('Sub');\nconst Mul = BinOp.extend('Mul');\nconst Div = BinOp.extend('Div');\nconst FloorDiv = BinOp.extend('FloorDiv');\nconst Mod = BinOp.extend('Mod');\nconst Pow = BinOp.extend('Pow');\nconst Neg = UnaryOp.extend('Neg');\nconst Pos = UnaryOp.extend('Pos');\nconst Compare = Node.extend('Compare', { fields: ['expr', 'ops'] });\nconst CompareOperand = Node.extend('CompareOperand', { fields: ['expr', 'type'] });\nconst CallExtension = Node.extend('CallExtension', {\n  init(ext, prop, args, contentArgs) {\n    this.parent();\n    this.extName = ext.__name || ext;\n    this.prop = prop;\n    this.args = args || new NodeList();\n    this.contentArgs = contentArgs || [];\n    this.autoescape = ext.autoescape;\n  },\n  fields: ['extName', 'prop', 'args', 'contentArgs']\n});\nconst CallExtensionAsync = CallExtension.extend('CallExtensionAsync');\n\n// This is hacky, but this is just a debugging function anyway\nfunction print(str, indent, inline) {\n  var lines = str.split('\\n');\n\n  lines.forEach((line, i) => {\n    if (line && ((inline && i > 0) || !inline)) {\n      process.stdout.write((' ').repeat(indent));\n    }\n    const nl = (i === lines.length - 1) ? '' : '\\n';\n    process.stdout.write(`${line}${nl}`);\n  });\n}\n\n// Print the AST in a nicely formatted tree format for debuggin\nfunction printNodes(node, indent) {\n  indent = indent || 0;\n\n  print(node.typename + ': ', indent);\n\n  if (node instanceof NodeList) {\n    print('\\n');\n    node.children.forEach((n) => {\n      printNodes(n, indent + 2);\n    });\n  } else if (node instanceof CallExtension) {\n    print(`${node.extName}.${node.prop}\\n`);\n\n    if (node.args) {\n      printNodes(node.args, indent + 2);\n    }\n\n    if (node.contentArgs) {\n      node.contentArgs.forEach((n) => {\n        printNodes(n, indent + 2);\n      });\n    }\n  } else {\n    let nodes = [];\n    let props = null;\n\n    node.iterFields((val, fieldName) => {\n      if (val instanceof Node) {\n        nodes.push([fieldName, val]);\n      } else {\n        props = props || {};\n        props[fieldName] = val;\n      }\n    });\n\n    if (props) {\n      print(JSON.stringify(props, null, 2) + '\\n', null, true);\n    } else {\n      print('\\n');\n    }\n\n    nodes.forEach(([fieldName, n]) => {\n      print(`[${fieldName}] =>`, indent + 2);\n      printNodes(n, indent + 4);\n    });\n  }\n}\n\nmodule.exports = {\n  Node: Node,\n  Root: Root,\n  NodeList: NodeList,\n  Value: Value,\n  Literal: Literal,\n  Symbol: Symbol,\n  Group: Group,\n  Array: ArrayNode,\n  Pair: Pair,\n  Dict: Dict,\n  Output: Output,\n  Capture: Capture,\n  TemplateData: TemplateData,\n  If: If,\n  IfAsync: IfAsync,\n  InlineIf: InlineIf,\n  For: For,\n  AsyncEach: AsyncEach,\n  AsyncAll: AsyncAll,\n  Macro: Macro,\n  Caller: Caller,\n  Import: Import,\n  FromImport: FromImport,\n  FunCall: FunCall,\n  Filter: Filter,\n  FilterAsync: FilterAsync,\n  KeywordArgs: KeywordArgs,\n  Block: Block,\n  Super: Super,\n  Extends: Extends,\n  Include: Include,\n  Set: Set,\n  Switch: Switch,\n  Case: Case,\n  LookupVal: LookupVal,\n  BinOp: BinOp,\n  In: In,\n  Is: Is,\n  Or: Or,\n  And: And,\n  Not: Not,\n  Add: Add,\n  Concat: Concat,\n  Sub: Sub,\n  Mul: Mul,\n  Div: Div,\n  FloorDiv: FloorDiv,\n  Mod: Mod,\n  Pow: Pow,\n  Neg: Neg,\n  Pos: Pos,\n  Compare: Compare,\n  CompareOperand: CompareOperand,\n\n  CallExtension: CallExtension,\n  CallExtensionAsync: CallExtensionAsync,\n\n  printNodes: printNodes\n};\n\n\n\n// WEBPACK FOOTER //\n// ./nunjucks/src/nodes.js","'use strict';\n\nconst parser = require('./parser');\nconst transformer = require('./transformer');\nconst nodes = require('./nodes');\nconst {TemplateError} = require('./lib');\nconst {Frame} = require('./runtime');\nconst {Obj} = require('./object');\n\n// These are all the same for now, but shouldn't be passed straight\n// through\nconst compareOps = {\n  '==': '==',\n  '===': '===',\n  '!=': '!=',\n  '!==': '!==',\n  '<': '<',\n  '>': '>',\n  '<=': '<=',\n  '>=': '>='\n};\n\nclass Compiler extends Obj {\n  init(templateName, throwOnUndefined) {\n    this.templateName = templateName;\n    this.codebuf = [];\n    this.lastId = 0;\n    this.buffer = null;\n    this.bufferStack = [];\n    this._scopeClosers = '';\n    this.inBlock = false;\n    this.throwOnUndefined = throwOnUndefined;\n  }\n\n  fail(msg, lineno, colno) {\n    if (lineno !== undefined) {\n      lineno += 1;\n    }\n    if (colno !== undefined) {\n      colno += 1;\n    }\n\n    throw new TemplateError(msg, lineno, colno);\n  }\n\n  _pushBuffer() {\n    const id = this._tmpid();\n    this.bufferStack.push(this.buffer);\n    this.buffer = id;\n    this._emit(`var ${this.buffer} = \"\";`);\n    return id;\n  }\n\n  _popBuffer() {\n    this.buffer = this.bufferStack.pop();\n  }\n\n  _emit(code) {\n    this.codebuf.push(code);\n  }\n\n  _emitLine(code) {\n    this._emit(code + '\\n');\n  }\n\n  _emitLines(...lines) {\n    lines.forEach((line) => this._emitLine(line));\n  }\n\n  _emitFuncBegin(node, name) {\n    this.buffer = 'output';\n    this._scopeClosers = '';\n    this._emitLine(`function ${name}(env, context, frame, runtime, cb) {`);\n    this._emitLine(`var lineno = ${node.lineno};`);\n    this._emitLine(`var colno = ${node.colno};`);\n    this._emitLine(`var ${this.buffer} = \"\";`);\n    this._emitLine('try {');\n  }\n\n  _emitFuncEnd(noReturn) {\n    if (!noReturn) {\n      this._emitLine('cb(null, ' + this.buffer + ');');\n    }\n\n    this._closeScopeLevels();\n    this._emitLine('} catch (e) {');\n    this._emitLine('  cb(runtime.handleError(e, lineno, colno));');\n    this._emitLine('}');\n    this._emitLine('}');\n    this.buffer = null;\n  }\n\n  _addScopeLevel() {\n    this._scopeClosers += '})';\n  }\n\n  _closeScopeLevels() {\n    this._emitLine(this._scopeClosers + ';');\n    this._scopeClosers = '';\n  }\n\n  _withScopedSyntax(func) {\n    var _scopeClosers = this._scopeClosers;\n    this._scopeClosers = '';\n\n    func.call(this);\n\n    this._closeScopeLevels();\n    this._scopeClosers = _scopeClosers;\n  }\n\n  _makeCallback(res) {\n    var err = this._tmpid();\n\n    return 'function(' + err + (res ? ',' + res : '') + ') {\\n' +\n      'if(' + err + ') { cb(' + err + '); return; }';\n  }\n\n  _tmpid() {\n    this.lastId++;\n    return 't_' + this.lastId;\n  }\n\n  _templateName() {\n    return this.templateName == null ? 'undefined' : JSON.stringify(this.templateName);\n  }\n\n  _compileChildren(node, frame) {\n    node.children.forEach((child) => {\n      this.compile(child, frame);\n    });\n  }\n\n  _compileAggregate(node, frame, startChar, endChar) {\n    if (startChar) {\n      this._emit(startChar);\n    }\n\n    node.children.forEach((child, i) => {\n      if (i > 0) {\n        this._emit(',');\n      }\n\n      this.compile(child, frame);\n    });\n\n    if (endChar) {\n      this._emit(endChar);\n    }\n  }\n\n  _compileExpression(node, frame) {\n    // TODO: I'm not really sure if this type check is worth it or\n    // not.\n    this.assertType(\n      node,\n      nodes.Literal,\n      nodes.Symbol,\n      nodes.Group,\n      nodes.Array,\n      nodes.Dict,\n      nodes.FunCall,\n      nodes.Caller,\n      nodes.Filter,\n      nodes.LookupVal,\n      nodes.Compare,\n      nodes.InlineIf,\n      nodes.In,\n      nodes.Is,\n      nodes.And,\n      nodes.Or,\n      nodes.Not,\n      nodes.Add,\n      nodes.Concat,\n      nodes.Sub,\n      nodes.Mul,\n      nodes.Div,\n      nodes.FloorDiv,\n      nodes.Mod,\n      nodes.Pow,\n      nodes.Neg,\n      nodes.Pos,\n      nodes.Compare,\n      nodes.NodeList\n    );\n    this.compile(node, frame);\n  }\n\n  assertType(node, ...types) {\n    if (!types.some(t => node instanceof t)) {\n      this.fail(`assertType: invalid type: ${node.typename}`, node.lineno, node.colno);\n    }\n  }\n\n  compileCallExtension(node, frame, async) {\n    var args = node.args;\n    var contentArgs = node.contentArgs;\n    var autoescape = typeof node.autoescape === 'boolean' ? node.autoescape : true;\n\n    if (!async) {\n      this._emit(`${this.buffer} += runtime.suppressValue(`);\n    }\n\n    this._emit(`env.getExtension(\"${node.extName}\")[\"${node.prop}\"](`);\n    this._emit('context');\n\n    if (args || contentArgs) {\n      this._emit(',');\n    }\n\n    if (args) {\n      if (!(args instanceof nodes.NodeList)) {\n        this.fail('compileCallExtension: arguments must be a NodeList, ' +\n          'use `parser.parseSignature`');\n      }\n\n      args.children.forEach((arg, i) => {\n        // Tag arguments are passed normally to the call. Note\n        // that keyword arguments are turned into a single js\n        // object as the last argument, if they exist.\n        this._compileExpression(arg, frame);\n\n        if (i !== args.children.length - 1 || contentArgs.length) {\n          this._emit(',');\n        }\n      });\n    }\n\n    if (contentArgs.length) {\n      contentArgs.forEach((arg, i) => {\n        if (i > 0) {\n          this._emit(',');\n        }\n\n        if (arg) {\n          this._emitLine('function(cb) {');\n          this._emitLine('if(!cb) { cb = function(err) { if(err) { throw err; }}}');\n          const id = this._pushBuffer();\n\n          this._withScopedSyntax(() => {\n            this.compile(arg, frame);\n            this._emitLine(`cb(null, ${id});`);\n          });\n\n          this._popBuffer();\n          this._emitLine(`return ${id};`);\n          this._emitLine('}');\n        } else {\n          this._emit('null');\n        }\n      });\n    }\n\n    if (async) {\n      const res = this._tmpid();\n      this._emitLine(', ' + this._makeCallback(res));\n      this._emitLine(\n        `${this.buffer} += runtime.suppressValue(${res}, ${autoescape} && env.opts.autoescape);`);\n      this._addScopeLevel();\n    } else {\n      this._emit(')');\n      this._emit(`, ${autoescape} && env.opts.autoescape);\\n`);\n    }\n  }\n\n  compileCallExtensionAsync(node, frame) {\n    this.compileCallExtension(node, frame, true);\n  }\n\n  compileNodeList(node, frame) {\n    this._compileChildren(node, frame);\n  }\n\n  compileLiteral(node) {\n    if (typeof node.value === 'string') {\n      let val = node.value.replace(/\\\\/g, '\\\\\\\\');\n      val = val.replace(/\"/g, '\\\\\"');\n      val = val.replace(/\\n/g, '\\\\n');\n      val = val.replace(/\\r/g, '\\\\r');\n      val = val.replace(/\\t/g, '\\\\t');\n      val = val.replace(/\\u2028/g, '\\\\u2028');\n      this._emit(`\"${val}\"`);\n    } else if (node.value === null) {\n      this._emit('null');\n    } else {\n      this._emit(node.value.toString());\n    }\n  }\n\n  compileSymbol(node, frame) {\n    var name = node.value;\n    var v = frame.lookup(name);\n\n    if (v) {\n      this._emit(v);\n    } else {\n      this._emit('runtime.contextOrFrameLookup(' +\n        'context, frame, \"' + name + '\")');\n    }\n  }\n\n  compileGroup(node, frame) {\n    this._compileAggregate(node, frame, '(', ')');\n  }\n\n  compileArray(node, frame) {\n    this._compileAggregate(node, frame, '[', ']');\n  }\n\n  compileDict(node, frame) {\n    this._compileAggregate(node, frame, '{', '}');\n  }\n\n  compilePair(node, frame) {\n    var key = node.key;\n    var val = node.value;\n\n    if (key instanceof nodes.Symbol) {\n      key = new nodes.Literal(key.lineno, key.colno, key.value);\n    } else if (!(key instanceof nodes.Literal &&\n      typeof key.value === 'string')) {\n      this.fail('compilePair: Dict keys must be strings or names',\n        key.lineno,\n        key.colno);\n    }\n\n    this.compile(key, frame);\n    this._emit(': ');\n    this._compileExpression(val, frame);\n  }\n\n  compileInlineIf(node, frame) {\n    this._emit('(');\n    this.compile(node.cond, frame);\n    this._emit('?');\n    this.compile(node.body, frame);\n    this._emit(':');\n    if (node.else_ !== null) {\n      this.compile(node.else_, frame);\n    } else {\n      this._emit('\"\"');\n    }\n    this._emit(')');\n  }\n\n  compileIn(node, frame) {\n    this._emit('runtime.inOperator(');\n    this.compile(node.left, frame);\n    this._emit(',');\n    this.compile(node.right, frame);\n    this._emit(')');\n  }\n\n  compileIs(node, frame) {\n    // first, we need to try to get the name of the test function, if it's a\n    // callable (i.e., has args) and not a symbol.\n    var right = node.right.name\n      ? node.right.name.value\n      // otherwise go with the symbol value\n      : node.right.value;\n    this._emit('env.getTest(\"' + right + '\").call(context, ');\n    this.compile(node.left, frame);\n    // compile the arguments for the callable if they exist\n    if (node.right.args) {\n      this._emit(',');\n      this.compile(node.right.args, frame);\n    }\n    this._emit(') === true');\n  }\n\n  _binOpEmitter(node, frame, str) {\n    this.compile(node.left, frame);\n    this._emit(str);\n    this.compile(node.right, frame);\n  }\n\n  // ensure concatenation instead of addition\n  // by adding empty string in between\n  compileOr(node, frame) {\n    return this._binOpEmitter(node, frame, ' || ');\n  }\n\n  compileAnd(node, frame) {\n    return this._binOpEmitter(node, frame, ' && ');\n  }\n\n  compileAdd(node, frame) {\n    return this._binOpEmitter(node, frame, ' + ');\n  }\n\n  compileConcat(node, frame) {\n    return this._binOpEmitter(node, frame, ' + \"\" + ');\n  }\n\n  compileSub(node, frame) {\n    return this._binOpEmitter(node, frame, ' - ');\n  }\n\n  compileMul(node, frame) {\n    return this._binOpEmitter(node, frame, ' * ');\n  }\n\n  compileDiv(node, frame) {\n    return this._binOpEmitter(node, frame, ' / ');\n  }\n\n  compileMod(node, frame) {\n    return this._binOpEmitter(node, frame, ' % ');\n  }\n\n  compileNot(node, frame) {\n    this._emit('!');\n    this.compile(node.target, frame);\n  }\n\n  compileFloorDiv(node, frame) {\n    this._emit('Math.floor(');\n    this.compile(node.left, frame);\n    this._emit(' / ');\n    this.compile(node.right, frame);\n    this._emit(')');\n  }\n\n  compilePow(node, frame) {\n    this._emit('Math.pow(');\n    this.compile(node.left, frame);\n    this._emit(', ');\n    this.compile(node.right, frame);\n    this._emit(')');\n  }\n\n  compileNeg(node, frame) {\n    this._emit('-');\n    this.compile(node.target, frame);\n  }\n\n  compilePos(node, frame) {\n    this._emit('+');\n    this.compile(node.target, frame);\n  }\n\n  compileCompare(node, frame) {\n    this.compile(node.expr, frame);\n\n    node.ops.forEach((op) => {\n      this._emit(` ${compareOps[op.type]} `);\n      this.compile(op.expr, frame);\n    });\n  }\n\n  compileLookupVal(node, frame) {\n    this._emit('runtime.memberLookup((');\n    this._compileExpression(node.target, frame);\n    this._emit('),');\n    this._compileExpression(node.val, frame);\n    this._emit(')');\n  }\n\n  _getNodeName(node) {\n    switch (node.typename) {\n      case 'Symbol':\n        return node.value;\n      case 'FunCall':\n        return 'the return value of (' + this._getNodeName(node.name) + ')';\n      case 'LookupVal':\n        return this._getNodeName(node.target) + '[\"' +\n          this._getNodeName(node.val) + '\"]';\n      case 'Literal':\n        return node.value.toString();\n      default:\n        return '--expression--';\n    }\n  }\n\n  compileFunCall(node, frame) {\n    // Keep track of line/col info at runtime by settings\n    // variables within an expression. An expression in javascript\n    // like (x, y, z) returns the last value, and x and y can be\n    // anything\n    this._emit('(lineno = ' + node.lineno +\n      ', colno = ' + node.colno + ', ');\n\n    this._emit('runtime.callWrap(');\n    // Compile it as normal.\n    this._compileExpression(node.name, frame);\n\n    // Output the name of what we're calling so we can get friendly errors\n    // if the lookup fails.\n    this._emit(', \"' + this._getNodeName(node.name).replace(/\"/g, '\\\\\"') + '\", context, ');\n\n    this._compileAggregate(node.args, frame, '[', '])');\n\n    this._emit(')');\n  }\n\n  compileFilter(node, frame) {\n    var name = node.name;\n    this.assertType(name, nodes.Symbol);\n    this._emit('env.getFilter(\"' + name.value + '\").call(context, ');\n    this._compileAggregate(node.args, frame);\n    this._emit(')');\n  }\n\n  compileFilterAsync(node, frame) {\n    var name = node.name;\n    var symbol = node.symbol.value;\n\n    this.assertType(name, nodes.Symbol);\n\n    frame.set(symbol, symbol);\n\n    this._emit('env.getFilter(\"' + name.value + '\").call(context, ');\n    this._compileAggregate(node.args, frame);\n    this._emitLine(', ' + this._makeCallback(symbol));\n\n    this._addScopeLevel();\n  }\n\n  compileKeywordArgs(node, frame) {\n    this._emit('runtime.makeKeywordArgs(');\n    this.compileDict(node, frame);\n    this._emit(')');\n  }\n\n  compileSet(node, frame) {\n    var ids = [];\n\n    // Lookup the variable names for each identifier and create\n    // new ones if necessary\n    node.targets.forEach((target) => {\n      var name = target.value;\n      var id = frame.lookup(name);\n\n      if (id === null || id === undefined) {\n        id = this._tmpid();\n\n        // Note: This relies on js allowing scope across\n        // blocks, in case this is created inside an `if`\n        this._emitLine('var ' + id + ';');\n      }\n\n      ids.push(id);\n    });\n\n    if (node.value) {\n      this._emit(ids.join(' = ') + ' = ');\n      this._compileExpression(node.value, frame);\n      this._emitLine(';');\n    } else {\n      this._emit(ids.join(' = ') + ' = ');\n      this.compile(node.body, frame);\n      this._emitLine(';');\n    }\n\n    node.targets.forEach((target, i) => {\n      var id = ids[i];\n      var name = target.value;\n\n      // We are running this for every var, but it's very\n      // uncommon to assign to multiple vars anyway\n      this._emitLine(`frame.set(\"${name}\", ${id}, true);`);\n\n      this._emitLine('if(frame.topLevel) {');\n      this._emitLine(`context.setVariable(\"${name}\", ${id});`);\n      this._emitLine('}');\n\n      if (name.charAt(0) !== '_') {\n        this._emitLine('if(frame.topLevel) {');\n        this._emitLine(`context.addExport(\"${name}\", ${id});`);\n        this._emitLine('}');\n      }\n    });\n  }\n\n  compileSwitch(node, frame) {\n    this._emit('switch (');\n    this.compile(node.expr, frame);\n    this._emit(') {');\n    node.cases.forEach((c, i) => {\n      this._emit('case ');\n      this.compile(c.cond, frame);\n      this._emit(': ');\n      this.compile(c.body, frame);\n      // preserve fall-throughs\n      if (c.body.children.length) {\n        this._emitLine('break;');\n      }\n    });\n    if (node.default) {\n      this._emit('default:');\n      this.compile(node.default, frame);\n    }\n    this._emit('}');\n  }\n\n  compileIf(node, frame, async) {\n    this._emit('if(');\n    this._compileExpression(node.cond, frame);\n    this._emitLine(') {');\n\n    this._withScopedSyntax(() => {\n      this.compile(node.body, frame);\n\n      if (async) {\n        this._emit('cb()');\n      }\n    });\n\n    if (node.else_) {\n      this._emitLine('}\\nelse {');\n\n      this._withScopedSyntax(() => {\n        this.compile(node.else_, frame);\n\n        if (async) {\n          this._emit('cb()');\n        }\n      });\n    } else if (async) {\n      this._emitLine('}\\nelse {');\n      this._emit('cb()');\n    }\n\n    this._emitLine('}');\n  }\n\n  compileIfAsync(node, frame) {\n    this._emit('(function(cb) {');\n    this.compileIf(node, frame, true);\n    this._emit('})(' + this._makeCallback());\n    this._addScopeLevel();\n  }\n\n  _emitLoopBindings(node, arr, i, len) {\n    const bindings = [\n      {name: 'index', val: `${i} + 1`},\n      {name: 'index0', val: i},\n      {name: 'revindex', val: `${len} - ${i}`},\n      {name: 'revindex0', val: `${len} - ${i} - 1`},\n      {name: 'first', val: `${i} === 0`},\n      {name: 'last', val: `${i} === ${len} - 1`},\n      {name: 'length', val: len},\n    ];\n\n    bindings.forEach((b) => {\n      this._emitLine(`frame.set(\"loop.${b.name}\", ${b.val});`);\n    });\n  }\n\n  compileFor(node, frame) {\n    // Some of this code is ugly, but it keeps the generated code\n    // as fast as possible. ForAsync also shares some of this, but\n    // not much.\n\n    const i = this._tmpid();\n    const len = this._tmpid();\n    const arr = this._tmpid();\n    frame = frame.push();\n\n    this._emitLine('frame = frame.push();');\n\n    this._emit(`var ${arr} = `);\n    this._compileExpression(node.arr, frame);\n    this._emitLine(';');\n\n    this._emit(`if(${arr}) {`);\n    this._emitLine(arr + ' = runtime.fromIterator(' + arr + ');');\n\n    // If multiple names are passed, we need to bind them\n    // appropriately\n    if (node.name instanceof nodes.Array) {\n      this._emitLine(`var ${i};`);\n\n      // The object could be an arroy or object. Note that the\n      // body of the loop is duplicated for each condition, but\n      // we are optimizing for speed over size.\n      this._emitLine(`if(runtime.isArray(${arr})) {`);\n      this._emitLine(`var ${len} = ${arr}.length;`);\n      this._emitLine(`for(${i}=0; ${i} < ${arr}.length; ${i}++) {`);\n\n      // Bind each declared var\n      node.name.children.forEach((child, u) => {\n        var tid = this._tmpid();\n        this._emitLine(`var ${tid} = ${arr}[${i}][${u}];`);\n        this._emitLine(`frame.set(\"${child}\", ${arr}[${i}][${u}]);`);\n        frame.set(node.name.children[u].value, tid);\n      });\n\n      this._emitLoopBindings(node, arr, i, len);\n      this._withScopedSyntax(() => {\n        this.compile(node.body, frame);\n      });\n      this._emitLine('}');\n\n      this._emitLine('} else {');\n      // Iterate over the key/values of an object\n      const [key, val] = node.name.children;\n      const k = this._tmpid();\n      const v = this._tmpid();\n      frame.set(key.value, k);\n      frame.set(val.value, v);\n\n      this._emitLine(`${i} = -1;`);\n      this._emitLine(`var ${len} = runtime.keys(${arr}).length;`);\n      this._emitLine(`for(var ${k} in ${arr}) {`);\n      this._emitLine(`${i}++;`);\n      this._emitLine(`var ${v} = ${arr}[${k}];`);\n      this._emitLine(`frame.set(\"${key.value}\", ${k});`);\n      this._emitLine(`frame.set(\"${val.value}\", ${v});`);\n\n      this._emitLoopBindings(node, arr, i, len);\n      this._withScopedSyntax(() => {\n        this.compile(node.body, frame);\n      });\n      this._emitLine('}');\n\n      this._emitLine('}');\n    } else {\n      // Generate a typical array iteration\n      const v = this._tmpid();\n      frame.set(node.name.value, v);\n\n      this._emitLine(`var ${len} = ${arr}.length;`);\n      this._emitLine(`for(var ${i}=0; ${i} < ${arr}.length; ${i}++) {`);\n      this._emitLine(`var ${v} = ${arr}[${i}];`);\n      this._emitLine(`frame.set(\"${node.name.value}\", ${v});`);\n\n      this._emitLoopBindings(node, arr, i, len);\n\n      this._withScopedSyntax(() => {\n        this.compile(node.body, frame);\n      });\n\n      this._emitLine('}');\n    }\n\n    this._emitLine('}');\n    if (node.else_) {\n      this._emitLine('if (!' + len + ') {');\n      this.compile(node.else_, frame);\n      this._emitLine('}');\n    }\n\n    this._emitLine('frame = frame.pop();');\n  }\n\n  _compileAsyncLoop(node, frame, parallel) {\n    // This shares some code with the For tag, but not enough to\n    // worry about. This iterates across an object asynchronously,\n    // but not in parallel.\n\n    var i = this._tmpid();\n    var len = this._tmpid();\n    var arr = this._tmpid();\n    var asyncMethod = parallel ? 'asyncAll' : 'asyncEach';\n    frame = frame.push();\n\n    this._emitLine('frame = frame.push();');\n\n    this._emit('var ' + arr + ' = runtime.fromIterator(');\n    this._compileExpression(node.arr, frame);\n    this._emitLine(');');\n\n    if (node.name instanceof nodes.Array) {\n      const arrayLen = node.name.children.length;\n      this._emit(`runtime.${asyncMethod}(${arr}, ${arrayLen}, function(`);\n\n      node.name.children.forEach((name) => {\n        this._emit(`${name.value},`);\n      });\n\n      this._emit(i + ',' + len + ',next) {');\n\n      node.name.children.forEach((name) => {\n        const id = name.value;\n        frame.set(id, id);\n        this._emitLine(`frame.set(\"${id}\", ${id});`);\n      });\n    } else {\n      const id = node.name.value;\n      this._emitLine(`runtime.${asyncMethod}(${arr}, 1, function(${id}, ${i}, ${len},next) {`);\n      this._emitLine('frame.set(\"' + id + '\", ' + id + ');');\n      frame.set(id, id);\n    }\n\n    this._emitLoopBindings(node, arr, i, len);\n\n    this._withScopedSyntax(() => {\n      let buf;\n      if (parallel) {\n        buf = this._pushBuffer();\n      }\n\n      this.compile(node.body, frame);\n      this._emitLine('next(' + i + (buf ? ',' + buf : '') + ');');\n\n      if (parallel) {\n        this._popBuffer();\n      }\n    });\n\n    const output = this._tmpid();\n    this._emitLine('}, ' + this._makeCallback(output));\n    this._addScopeLevel();\n\n    if (parallel) {\n      this._emitLine(this.buffer + ' += ' + output + ';');\n    }\n\n    if (node.else_) {\n      this._emitLine('if (!' + arr + '.length) {');\n      this.compile(node.else_, frame);\n      this._emitLine('}');\n    }\n\n    this._emitLine('frame = frame.pop();');\n  }\n\n  compileAsyncEach(node, frame) {\n    this._compileAsyncLoop(node, frame);\n  }\n\n  compileAsyncAll(node, frame) {\n    this._compileAsyncLoop(node, frame, true);\n  }\n\n  _compileMacro(node, frame) {\n    var args = [];\n    var kwargs = null;\n    var funcId = 'macro_' + this._tmpid();\n    var keepFrame = (frame !== undefined);\n\n    // Type check the definition of the args\n    node.args.children.forEach((arg, i) => {\n      if (i === node.args.children.length - 1 && arg instanceof nodes.Dict) {\n        kwargs = arg;\n      } else {\n        this.assertType(arg, nodes.Symbol);\n        args.push(arg);\n      }\n    });\n\n    const realNames = [...args.map((n) => `l_${n.value}`), 'kwargs'];\n\n    // Quoted argument names\n    const argNames = args.map((n) => `\"${n.value}\"`);\n    const kwargNames = ((kwargs && kwargs.children) || []).map((n) => `\"${n.key.value}\"`);\n\n    // We pass a function to makeMacro which destructures the\n    // arguments so support setting positional args with keywords\n    // args and passing keyword args as positional args\n    // (essentially default values). See runtime.js.\n    let currFrame;\n    if (keepFrame) {\n      currFrame = frame.push(true);\n    } else {\n      currFrame = new Frame();\n    }\n    this._emitLines(\n      `var ${funcId} = runtime.makeMacro(`,\n      `[${argNames.join(', ')}], `,\n      `[${kwargNames.join(', ')}], `,\n      `function (${realNames.join(', ')}) {`,\n      'var callerFrame = frame;',\n      'frame = ' + ((keepFrame) ? 'frame.push(true);' : 'new runtime.Frame();'),\n      'kwargs = kwargs || {};',\n      'if (Object.prototype.hasOwnProperty.call(kwargs, \"caller\")) {',\n      'frame.set(\"caller\", kwargs.caller); }');\n\n    // Expose the arguments to the template. Don't need to use\n    // random names because the function\n    // will create a new run-time scope for us\n    args.forEach((arg) => {\n      this._emitLine(`frame.set(\"${arg.value}\", l_${arg.value});`);\n      currFrame.set(arg.value, `l_${arg.value}`);\n    });\n\n    // Expose the keyword arguments\n    if (kwargs) {\n      kwargs.children.forEach((pair) => {\n        const name = pair.key.value;\n        this._emit(`frame.set(\"${name}\", `);\n        this._emit(`Object.prototype.hasOwnProperty.call(kwargs, \"${name}\")`);\n        this._emit(` ? kwargs[\"${name}\"] : `);\n        this._compileExpression(pair.value, currFrame);\n        this._emit(');');\n      });\n    }\n\n    const bufferId = this._pushBuffer();\n\n    this._withScopedSyntax(() => {\n      this.compile(node.body, currFrame);\n    });\n\n    this._emitLine('frame = ' + ((keepFrame) ? 'frame.pop();' : 'callerFrame;'));\n    this._emitLine(`return new runtime.SafeString(${bufferId});`);\n    this._emitLine('});');\n    this._popBuffer();\n\n    return funcId;\n  }\n\n  compileMacro(node, frame) {\n    var funcId = this._compileMacro(node);\n\n    // Expose the macro to the templates\n    var name = node.name.value;\n    frame.set(name, funcId);\n\n    if (frame.parent) {\n      this._emitLine(`frame.set(\"${name}\", ${funcId});`);\n    } else {\n      if (node.name.value.charAt(0) !== '_') {\n        this._emitLine(`context.addExport(\"${name}\");`);\n      }\n      this._emitLine(`context.setVariable(\"${name}\", ${funcId});`);\n    }\n  }\n\n  compileCaller(node, frame) {\n    // basically an anonymous \"macro expression\"\n    this._emit('(function (){');\n    const funcId = this._compileMacro(node, frame);\n    this._emit(`return ${funcId};})()`);\n  }\n\n  _compileGetTemplate(node, frame, eagerCompile, ignoreMissing) {\n    const parentTemplateId = this._tmpid();\n    const parentName = this._templateName();\n    const cb = this._makeCallback(parentTemplateId);\n    const eagerCompileArg = (eagerCompile) ? 'true' : 'false';\n    const ignoreMissingArg = (ignoreMissing) ? 'true' : 'false';\n    this._emit('env.getTemplate(');\n    this._compileExpression(node.template, frame);\n    this._emitLine(`, ${eagerCompileArg}, ${parentName}, ${ignoreMissingArg}, ${cb}`);\n    return parentTemplateId;\n  }\n\n  compileImport(node, frame) {\n    const target = node.target.value;\n    const id = this._compileGetTemplate(node, frame, false, false);\n    this._addScopeLevel();\n\n    this._emitLine(id + '.getExported(' +\n      (node.withContext ? 'context.getVariables(), frame, ' : '') +\n      this._makeCallback(id));\n    this._addScopeLevel();\n\n    frame.set(target, id);\n\n    if (frame.parent) {\n      this._emitLine(`frame.set(\"${target}\", ${id});`);\n    } else {\n      this._emitLine(`context.setVariable(\"${target}\", ${id});`);\n    }\n  }\n\n  compileFromImport(node, frame) {\n    const importedId = this._compileGetTemplate(node, frame, false, false);\n    this._addScopeLevel();\n\n    this._emitLine(importedId + '.getExported(' +\n      (node.withContext ? 'context.getVariables(), frame, ' : '') +\n      this._makeCallback(importedId));\n    this._addScopeLevel();\n\n    node.names.children.forEach((nameNode) => {\n      var name;\n      var alias;\n      var id = this._tmpid();\n\n      if (nameNode instanceof nodes.Pair) {\n        name = nameNode.key.value;\n        alias = nameNode.value.value;\n      } else {\n        name = nameNode.value;\n        alias = name;\n      }\n\n      this._emitLine(`if(Object.prototype.hasOwnProperty.call(${importedId}, \"${name}\")) {`);\n      this._emitLine(`var ${id} = ${importedId}.${name};`);\n      this._emitLine('} else {');\n      this._emitLine(`cb(new Error(\"cannot import '${name}'\")); return;`);\n      this._emitLine('}');\n\n      frame.set(alias, id);\n\n      if (frame.parent) {\n        this._emitLine(`frame.set(\"${alias}\", ${id});`);\n      } else {\n        this._emitLine(`context.setVariable(\"${alias}\", ${id});`);\n      }\n    });\n  }\n\n  compileBlock(node) {\n    var id = this._tmpid();\n\n    // If we are executing outside a block (creating a top-level\n    // block), we really don't want to execute its code because it\n    // will execute twice: once when the child template runs and\n    // again when the parent template runs. Note that blocks\n    // within blocks will *always* execute immediately *and*\n    // wherever else they are invoked (like used in a parent\n    // template). This may have behavioral differences from jinja\n    // because blocks can have side effects, but it seems like a\n    // waste of performance to always execute huge top-level\n    // blocks twice\n    if (!this.inBlock) {\n      this._emit('(parentTemplate ? function(e, c, f, r, cb) { cb(\"\"); } : ');\n    }\n    this._emit(`context.getBlock(\"${node.name.value}\")`);\n    if (!this.inBlock) {\n      this._emit(')');\n    }\n    this._emitLine('(env, context, frame, runtime, ' + this._makeCallback(id));\n    this._emitLine(`${this.buffer} += ${id};`);\n    this._addScopeLevel();\n  }\n\n  compileSuper(node, frame) {\n    var name = node.blockName.value;\n    var id = node.symbol.value;\n\n    const cb = this._makeCallback(id);\n    this._emitLine(`context.getSuper(env, \"${name}\", b_${name}, frame, runtime, ${cb}`);\n    this._emitLine(`${id} = runtime.markSafe(${id});`);\n    this._addScopeLevel();\n    frame.set(id, id);\n  }\n\n  compileExtends(node, frame) {\n    var k = this._tmpid();\n\n    const parentTemplateId = this._compileGetTemplate(node, frame, true, false);\n\n    // extends is a dynamic tag and can occur within a block like\n    // `if`, so if this happens we need to capture the parent\n    // template in the top-level scope\n    this._emitLine(`parentTemplate = ${parentTemplateId}`);\n\n    this._emitLine(`for(var ${k} in parentTemplate.blocks) {`);\n    this._emitLine(`context.addBlock(${k}, parentTemplate.blocks[${k}]);`);\n    this._emitLine('}');\n\n    this._addScopeLevel();\n  }\n\n  compileInclude(node, frame) {\n    this._emitLine('var tasks = [];');\n    this._emitLine('tasks.push(');\n    this._emitLine('function(callback) {');\n    const id = this._compileGetTemplate(node, frame, false, node.ignoreMissing);\n    this._emitLine(`callback(null,${id});});`);\n    this._emitLine('});');\n\n    const id2 = this._tmpid();\n    this._emitLine('tasks.push(');\n    this._emitLine('function(template, callback){');\n    this._emitLine('template.render(context.getVariables(), frame, ' + this._makeCallback(id2));\n    this._emitLine('callback(null,' + id2 + ');});');\n    this._emitLine('});');\n\n    this._emitLine('tasks.push(');\n    this._emitLine('function(result, callback){');\n    this._emitLine(`${this.buffer} += result;`);\n    this._emitLine('callback(null);');\n    this._emitLine('});');\n    this._emitLine('env.waterfall(tasks, function(){');\n    this._addScopeLevel();\n  }\n\n  compileTemplateData(node, frame) {\n    this.compileLiteral(node, frame);\n  }\n\n  compileCapture(node, frame) {\n    // we need to temporarily override the current buffer id as 'output'\n    // so the set block writes to the capture output instead of the buffer\n    var buffer = this.buffer;\n    this.buffer = 'output';\n    this._emitLine('(function() {');\n    this._emitLine('var output = \"\";');\n    this._withScopedSyntax(() => {\n      this.compile(node.body, frame);\n    });\n    this._emitLine('return output;');\n    this._emitLine('})()');\n    // and of course, revert back to the old buffer id\n    this.buffer = buffer;\n  }\n\n  compileOutput(node, frame) {\n    const children = node.children;\n    children.forEach(child => {\n      // TemplateData is a special case because it is never\n      // autoescaped, so simply output it for optimization\n      if (child instanceof nodes.TemplateData) {\n        if (child.value) {\n          this._emit(`${this.buffer} += `);\n          this.compileLiteral(child, frame);\n          this._emitLine(';');\n        }\n      } else {\n        this._emit(`${this.buffer} += runtime.suppressValue(`);\n        if (this.throwOnUndefined) {\n          this._emit('runtime.ensureDefined(');\n        }\n        this.compile(child, frame);\n        if (this.throwOnUndefined) {\n          this._emit(`,${node.lineno},${node.colno})`);\n        }\n        this._emit(', env.opts.autoescape);\\n');\n      }\n    });\n  }\n\n  compileRoot(node, frame) {\n    if (frame) {\n      this.fail('compileRoot: root node can\\'t have frame');\n    }\n\n    frame = new Frame();\n\n    this._emitFuncBegin(node, 'root');\n    this._emitLine('var parentTemplate = null;');\n    this._compileChildren(node, frame);\n    this._emitLine('if(parentTemplate) {');\n    this._emitLine('parentTemplate.rootRenderFunc(env, context, frame, runtime, cb);');\n    this._emitLine('} else {');\n    this._emitLine(`cb(null, ${this.buffer});`);\n    this._emitLine('}');\n    this._emitFuncEnd(true);\n\n    this.inBlock = true;\n\n    const blockNames = [];\n\n    const blocks = node.findAll(nodes.Block);\n\n    blocks.forEach((block, i) => {\n      const name = block.name.value;\n\n      if (blockNames.indexOf(name) !== -1) {\n        throw new Error(`Block \"${name}\" defined more than once.`);\n      }\n      blockNames.push(name);\n\n      this._emitFuncBegin(block, `b_${name}`);\n\n      const tmpFrame = new Frame();\n      this._emitLine('var frame = frame.push(true);');\n      this.compile(block.body, tmpFrame);\n      this._emitFuncEnd();\n    });\n\n    this._emitLine('return {');\n\n    blocks.forEach((block, i) => {\n      const blockName = `b_${block.name.value}`;\n      this._emitLine(`${blockName}: ${blockName},`);\n    });\n\n    this._emitLine('root: root\\n};');\n  }\n\n  compile(node, frame) {\n    var _compile = this['compile' + node.typename];\n    if (_compile) {\n      _compile.call(this, node, frame);\n    } else {\n      this.fail(`compile: Cannot compile node: ${node.typename}`, node.lineno, node.colno);\n    }\n  }\n\n  getCode() {\n    return this.codebuf.join('');\n  }\n}\n\nmodule.exports = {\n  compile: function compile(src, asyncFilters, extensions, name, opts = {}) {\n    const c = new Compiler(name, opts.throwOnUndefined);\n\n    // Run the extension preprocessors against the source.\n    const preprocessors = (extensions || []).map(ext => ext.preprocess).filter(f => !!f);\n\n    const processedSrc = preprocessors.reduce((s, processor) => processor(s), src);\n\n    c.compile(transformer.transform(\n      parser.parse(processedSrc, extensions, opts),\n      asyncFilters,\n      name\n    ));\n    return c.getCode();\n  },\n\n  Compiler: Compiler\n};\n\n\n\n// WEBPACK FOOTER //\n// ./nunjucks/src/compiler.js","'use strict';\n\nconst path = require('path');\nconst {EmitterObj} = require('./object');\n\nmodule.exports = class Loader extends EmitterObj {\n  resolve(from, to) {\n    return path.resolve(path.dirname(from), to);\n  }\n\n  isRelative(filename) {\n    return (filename.indexOf('./') === 0 || filename.indexOf('../') === 0);\n  }\n};\n\n\n\n// WEBPACK FOOTER //\n// ./nunjucks/src/loader.js","'use strict';\n\nconst asap = require('asap');\nconst waterfall = require('a-sync-waterfall');\nconst lib = require('./lib');\nconst compiler = require('./compiler');\nconst filters = require('./filters');\nconst {FileSystemLoader, WebLoader, PrecompiledLoader} = require('./loaders');\nconst tests = require('./tests');\nconst globals = require('./globals');\nconst {Obj, EmitterObj} = require('./object');\nconst globalRuntime = require('./runtime');\nconst {handleError, Frame} = globalRuntime;\nconst expressApp = require('./express-app');\n\n// If the user is using the async API, *always* call it\n// asynchronously even if the template was synchronous.\nfunction callbackAsap(cb, err, res) {\n  asap(() => {\n    cb(err, res);\n  });\n}\n\n/**\n * A no-op template, for use with {% include ignore missing %}\n */\nconst noopTmplSrc = {\n  type: 'code',\n  obj: {\n    root(env, context, frame, runtime, cb) {\n      try {\n        cb(null, '');\n      } catch (e) {\n        cb(handleError(e, null, null));\n      }\n    }\n  }\n};\n\nclass Environment extends EmitterObj {\n  init(loaders, opts) {\n    // The dev flag determines the trace that'll be shown on errors.\n    // If set to true, returns the full trace from the error point,\n    // otherwise will return trace starting from Template.render\n    // (the full trace from within nunjucks may confuse developers using\n    //  the library)\n    // defaults to false\n    opts = this.opts = opts || {};\n    this.opts.dev = !!opts.dev;\n\n    // The autoescape flag sets global autoescaping. If true,\n    // every string variable will be escaped by default.\n    // If false, strings can be manually escaped using the `escape` filter.\n    // defaults to true\n    this.opts.autoescape = opts.autoescape != null ? opts.autoescape : true;\n\n    // If true, this will make the system throw errors if trying\n    // to output a null or undefined value\n    this.opts.throwOnUndefined = !!opts.throwOnUndefined;\n    this.opts.trimBlocks = !!opts.trimBlocks;\n    this.opts.lstripBlocks = !!opts.lstripBlocks;\n\n    this.loaders = [];\n\n    if (!loaders) {\n      // The filesystem loader is only available server-side\n      if (FileSystemLoader) {\n        this.loaders = [new FileSystemLoader('views')];\n      } else if (WebLoader) {\n        this.loaders = [new WebLoader('/views')];\n      }\n    } else {\n      this.loaders = lib.isArray(loaders) ? loaders : [loaders];\n    }\n\n    // It's easy to use precompiled templates: just include them\n    // before you configure nunjucks and this will automatically\n    // pick it up and use it\n    if (typeof window !== 'undefined' && window.nunjucksPrecompiled) {\n      this.loaders.unshift(\n        new PrecompiledLoader(window.nunjucksPrecompiled)\n      );\n    }\n\n    this._initLoaders();\n\n    this.globals = globals();\n    this.filters = {};\n    this.tests = {};\n    this.asyncFilters = [];\n    this.extensions = {};\n    this.extensionsList = [];\n\n    lib._entries(filters).forEach(([name, filter]) => this.addFilter(name, filter));\n    lib._entries(tests).forEach(([name, test]) => this.addTest(name, test));\n  }\n\n  _initLoaders() {\n    this.loaders.forEach((loader) => {\n      // Caching and cache busting\n      loader.cache = {};\n      if (typeof loader.on === 'function') {\n        loader.on('update', (name, fullname) => {\n          loader.cache[name] = null;\n          this.emit('update', name, fullname, loader);\n        });\n        loader.on('load', (name, source) => {\n          this.emit('load', name, source, loader);\n        });\n      }\n    });\n  }\n\n  invalidateCache() {\n    this.loaders.forEach((loader) => {\n      loader.cache = {};\n    });\n  }\n\n  addExtension(name, extension) {\n    extension.__name = name;\n    this.extensions[name] = extension;\n    this.extensionsList.push(extension);\n    return this;\n  }\n\n  removeExtension(name) {\n    var extension = this.getExtension(name);\n    if (!extension) {\n      return;\n    }\n\n    this.extensionsList = lib.without(this.extensionsList, extension);\n    delete this.extensions[name];\n  }\n\n  getExtension(name) {\n    return this.extensions[name];\n  }\n\n  hasExtension(name) {\n    return !!this.extensions[name];\n  }\n\n  addGlobal(name, value) {\n    this.globals[name] = value;\n    return this;\n  }\n\n  getGlobal(name) {\n    if (typeof this.globals[name] === 'undefined') {\n      throw new Error('global not found: ' + name);\n    }\n    return this.globals[name];\n  }\n\n  addFilter(name, func, async) {\n    var wrapped = func;\n\n    if (async) {\n      this.asyncFilters.push(name);\n    }\n    this.filters[name] = wrapped;\n    return this;\n  }\n\n  getFilter(name) {\n    if (!this.filters[name]) {\n      throw new Error('filter not found: ' + name);\n    }\n    return this.filters[name];\n  }\n\n  addTest(name, func) {\n    this.tests[name] = func;\n    return this;\n  }\n\n  getTest(name) {\n    if (!this.tests[name]) {\n      throw new Error('test not found: ' + name);\n    }\n    return this.tests[name];\n  }\n\n  resolveTemplate(loader, parentName, filename) {\n    var isRelative = (loader.isRelative && parentName) ? loader.isRelative(filename) : false;\n    return (isRelative && loader.resolve) ? loader.resolve(parentName, filename) : filename;\n  }\n\n  getTemplate(name, eagerCompile, parentName, ignoreMissing, cb) {\n    var that = this;\n    var tmpl = null;\n    if (name && name.raw) {\n      // this fixes autoescape for templates referenced in symbols\n      name = name.raw;\n    }\n\n    if (lib.isFunction(parentName)) {\n      cb = parentName;\n      parentName = null;\n      eagerCompile = eagerCompile || false;\n    }\n\n    if (lib.isFunction(eagerCompile)) {\n      cb = eagerCompile;\n      eagerCompile = false;\n    }\n\n    if (name instanceof Template) {\n      tmpl = name;\n    } else if (typeof name !== 'string') {\n      throw new Error('template names must be a string: ' + name);\n    } else {\n      for (let i = 0; i < this.loaders.length; i++) {\n        const loader = this.loaders[i];\n        tmpl = loader.cache[this.resolveTemplate(loader, parentName, name)];\n        if (tmpl) {\n          break;\n        }\n      }\n    }\n\n    if (tmpl) {\n      if (eagerCompile) {\n        tmpl.compile();\n      }\n\n      if (cb) {\n        cb(null, tmpl);\n        return undefined;\n      } else {\n        return tmpl;\n      }\n    }\n    let syncResult;\n\n    const createTemplate = (err, info) => {\n      if (!info && !err && !ignoreMissing) {\n        err = new Error('template not found: ' + name);\n      }\n\n      if (err) {\n        if (cb) {\n          cb(err);\n          return;\n        } else {\n          throw err;\n        }\n      }\n      let newTmpl;\n      if (!info) {\n        newTmpl = new Template(noopTmplSrc, this, '', eagerCompile);\n      } else {\n        newTmpl = new Template(info.src, this, info.path, eagerCompile);\n        if (!info.noCache) {\n          info.loader.cache[name] = newTmpl;\n        }\n      }\n      if (cb) {\n        cb(null, newTmpl);\n      } else {\n        syncResult = newTmpl;\n      }\n    };\n\n    lib.asyncIter(this.loaders, (loader, i, next, done) => {\n      function handle(err, src) {\n        if (err) {\n          done(err);\n        } else if (src) {\n          src.loader = loader;\n          done(null, src);\n        } else {\n          next();\n        }\n      }\n\n      // Resolve name relative to parentName\n      name = that.resolveTemplate(loader, parentName, name);\n\n      if (loader.async) {\n        loader.getSource(name, handle);\n      } else {\n        handle(null, loader.getSource(name));\n      }\n    }, createTemplate);\n\n    return syncResult;\n  }\n\n  express(app) {\n    return expressApp(this, app);\n  }\n\n  render(name, ctx, cb) {\n    if (lib.isFunction(ctx)) {\n      cb = ctx;\n      ctx = null;\n    }\n\n    // We support a synchronous API to make it easier to migrate\n    // existing code to async. This works because if you don't do\n    // anything async work, the whole thing is actually run\n    // synchronously.\n    let syncResult = null;\n\n    this.getTemplate(name, (err, tmpl) => {\n      if (err && cb) {\n        callbackAsap(cb, err);\n      } else if (err) {\n        throw err;\n      } else {\n        syncResult = tmpl.render(ctx, cb);\n      }\n    });\n\n    return syncResult;\n  }\n\n  renderString(src, ctx, opts, cb) {\n    if (lib.isFunction(opts)) {\n      cb = opts;\n      opts = {};\n    }\n    opts = opts || {};\n\n    const tmpl = new Template(src, this, opts.path);\n    return tmpl.render(ctx, cb);\n  }\n\n  waterfall(tasks, callback, forceAsync) {\n    return waterfall(tasks, callback, forceAsync);\n  }\n}\n\nclass Context extends Obj {\n  init(ctx, blocks, env) {\n    // Has to be tied to an environment so we can tap into its globals.\n    this.env = env || new Environment();\n\n    // Make a duplicate of ctx\n    this.ctx = lib.extend({}, ctx);\n\n    this.blocks = {};\n    this.exported = [];\n\n    lib.keys(blocks).forEach(name => {\n      this.addBlock(name, blocks[name]);\n    });\n  }\n\n  lookup(name) {\n    // This is one of the most called functions, so optimize for\n    // the typical case where the name isn't in the globals\n    if (name in this.env.globals && !(name in this.ctx)) {\n      return this.env.globals[name];\n    } else {\n      return this.ctx[name];\n    }\n  }\n\n  setVariable(name, val) {\n    this.ctx[name] = val;\n  }\n\n  getVariables() {\n    return this.ctx;\n  }\n\n  addBlock(name, block) {\n    this.blocks[name] = this.blocks[name] || [];\n    this.blocks[name].push(block);\n    return this;\n  }\n\n  getBlock(name) {\n    if (!this.blocks[name]) {\n      throw new Error('unknown block \"' + name + '\"');\n    }\n\n    return this.blocks[name][0];\n  }\n\n  getSuper(env, name, block, frame, runtime, cb) {\n    var idx = lib.indexOf(this.blocks[name] || [], block);\n    var blk = this.blocks[name][idx + 1];\n    var context = this;\n\n    if (idx === -1 || !blk) {\n      throw new Error('no super block available for \"' + name + '\"');\n    }\n\n    blk(env, context, frame, runtime, cb);\n  }\n\n  addExport(name) {\n    this.exported.push(name);\n  }\n\n  getExported() {\n    var exported = {};\n    this.exported.forEach((name) => {\n      exported[name] = this.ctx[name];\n    });\n    return exported;\n  }\n}\n\nclass Template extends Obj {\n  init(src, env, path, eagerCompile) {\n    this.env = env || new Environment();\n\n    if (lib.isObject(src)) {\n      switch (src.type) {\n        case 'code':\n          this.tmplProps = src.obj;\n          break;\n        case 'string':\n          this.tmplStr = src.obj;\n          break;\n        default:\n          throw new Error(\n            `Unexpected template object type ${src.type}; expected 'code', or 'string'`);\n      }\n    } else if (lib.isString(src)) {\n      this.tmplStr = src;\n    } else {\n      throw new Error('src must be a string or an object describing the source');\n    }\n\n    this.path = path;\n\n    if (eagerCompile) {\n      try {\n        this._compile();\n      } catch (err) {\n        throw lib._prettifyError(this.path, this.env.opts.dev, err);\n      }\n    } else {\n      this.compiled = false;\n    }\n  }\n\n  render(ctx, parentFrame, cb) {\n    if (typeof ctx === 'function') {\n      cb = ctx;\n      ctx = {};\n    } else if (typeof parentFrame === 'function') {\n      cb = parentFrame;\n      parentFrame = null;\n    }\n\n    // If there is a parent frame, we are being called from internal\n    // code of another template, and the internal system\n    // depends on the sync/async nature of the parent template\n    // to be inherited, so force an async callback\n    const forceAsync = !parentFrame;\n\n    // Catch compile errors for async rendering\n    try {\n      this.compile();\n    } catch (e) {\n      const err = lib._prettifyError(this.path, this.env.opts.dev, e);\n      if (cb) {\n        return callbackAsap(cb, err);\n      } else {\n        throw err;\n      }\n    }\n\n    const context = new Context(ctx || {}, this.blocks, this.env);\n    const frame = parentFrame ? parentFrame.push(true) : new Frame();\n    frame.topLevel = true;\n    let syncResult = null;\n    let didError = false;\n\n    this.rootRenderFunc(this.env, context, frame, globalRuntime, (err, res) => {\n      // TODO: this is actually a bug in the compiled template (because waterfall\n      // tasks are both not passing errors up the chain of callbacks AND are not\n      // causing a return from the top-most render function). But fixing that\n      // will require a more substantial change to the compiler.\n      if (didError && cb && typeof res !== 'undefined') {\n        // prevent multiple calls to cb\n        return;\n      }\n\n      if (err) {\n        err = lib._prettifyError(this.path, this.env.opts.dev, err);\n        didError = true;\n      }\n\n      if (cb) {\n        if (forceAsync) {\n          callbackAsap(cb, err, res);\n        } else {\n          cb(err, res);\n        }\n      } else {\n        if (err) {\n          throw err;\n        }\n        syncResult = res;\n      }\n    });\n\n    return syncResult;\n  }\n\n\n  getExported(ctx, parentFrame, cb) { // eslint-disable-line consistent-return\n    if (typeof ctx === 'function') {\n      cb = ctx;\n      ctx = {};\n    }\n\n    if (typeof parentFrame === 'function') {\n      cb = parentFrame;\n      parentFrame = null;\n    }\n\n    // Catch compile errors for async rendering\n    try {\n      this.compile();\n    } catch (e) {\n      if (cb) {\n        return cb(e);\n      } else {\n        throw e;\n      }\n    }\n\n    const frame = parentFrame ? parentFrame.push() : new Frame();\n    frame.topLevel = true;\n\n    // Run the rootRenderFunc to populate the context with exported vars\n    const context = new Context(ctx || {}, this.blocks, this.env);\n    this.rootRenderFunc(this.env, context, frame, globalRuntime, (err) => {\n      if (err) {\n        cb(err, null);\n      } else {\n        cb(null, context.getExported());\n      }\n    });\n  }\n\n  compile() {\n    if (!this.compiled) {\n      this._compile();\n    }\n  }\n\n  _compile() {\n    var props;\n\n    if (this.tmplProps) {\n      props = this.tmplProps;\n    } else {\n      const source = compiler.compile(this.tmplStr,\n        this.env.asyncFilters,\n        this.env.extensionsList,\n        this.path,\n        this.env.opts);\n\n      const func = new Function(source); // eslint-disable-line no-new-func\n      props = func();\n    }\n\n    this.blocks = this._getBlocks(props);\n    this.rootRenderFunc = props.root;\n    this.compiled = true;\n  }\n\n  _getBlocks(props) {\n    var blocks = {};\n\n    lib.keys(props).forEach((k) => {\n      if (k.slice(0, 2) === 'b_') {\n        blocks[k.slice(2)] = props[k];\n      }\n    });\n\n    return blocks;\n  }\n}\n\nmodule.exports = {\n  Environment: Environment,\n  Template: Template\n};\n\n\n\n// WEBPACK FOOTER //\n// ./nunjucks/src/environment.js","'use strict';\n\nvar lexer = require('./lexer');\nvar nodes = require('./nodes');\nvar Obj = require('./object').Obj;\nvar lib = require('./lib');\n\nclass Parser extends Obj {\n  init(tokens) {\n    this.tokens = tokens;\n    this.peeked = null;\n    this.breakOnBlocks = null;\n    this.dropLeadingWhitespace = false;\n\n    this.extensions = [];\n  }\n\n  nextToken(withWhitespace) {\n    var tok;\n\n    if (this.peeked) {\n      if (!withWhitespace && this.peeked.type === lexer.TOKEN_WHITESPACE) {\n        this.peeked = null;\n      } else {\n        tok = this.peeked;\n        this.peeked = null;\n        return tok;\n      }\n    }\n\n    tok = this.tokens.nextToken();\n\n    if (!withWhitespace) {\n      while (tok && tok.type === lexer.TOKEN_WHITESPACE) {\n        tok = this.tokens.nextToken();\n      }\n    }\n\n    return tok;\n  }\n\n  peekToken() {\n    this.peeked = this.peeked || this.nextToken();\n    return this.peeked;\n  }\n\n  pushToken(tok) {\n    if (this.peeked) {\n      throw new Error('pushToken: can only push one token on between reads');\n    }\n    this.peeked = tok;\n  }\n\n  error(msg, lineno, colno) {\n    if (lineno === undefined || colno === undefined) {\n      const tok = this.peekToken() || {};\n      lineno = tok.lineno;\n      colno = tok.colno;\n    }\n    if (lineno !== undefined) {\n      lineno += 1;\n    }\n    if (colno !== undefined) {\n      colno += 1;\n    }\n    return new lib.TemplateError(msg, lineno, colno);\n  }\n\n  fail(msg, lineno, colno) {\n    throw this.error(msg, lineno, colno);\n  }\n\n  skip(type) {\n    var tok = this.nextToken();\n    if (!tok || tok.type !== type) {\n      this.pushToken(tok);\n      return false;\n    }\n    return true;\n  }\n\n  expect(type) {\n    var tok = this.nextToken();\n    if (tok.type !== type) {\n      this.fail('expected ' + type + ', got ' + tok.type,\n        tok.lineno,\n        tok.colno);\n    }\n    return tok;\n  }\n\n  skipValue(type, val) {\n    var tok = this.nextToken();\n    if (!tok || tok.type !== type || tok.value !== val) {\n      this.pushToken(tok);\n      return false;\n    }\n    return true;\n  }\n\n  skipSymbol(val) {\n    return this.skipValue(lexer.TOKEN_SYMBOL, val);\n  }\n\n  advanceAfterBlockEnd(name) {\n    var tok;\n    if (!name) {\n      tok = this.peekToken();\n\n      if (!tok) {\n        this.fail('unexpected end of file');\n      }\n\n      if (tok.type !== lexer.TOKEN_SYMBOL) {\n        this.fail('advanceAfterBlockEnd: expected symbol token or ' +\n          'explicit name to be passed');\n      }\n\n      name = this.nextToken().value;\n    }\n\n    tok = this.nextToken();\n\n    if (tok && tok.type === lexer.TOKEN_BLOCK_END) {\n      if (tok.value.charAt(0) === '-') {\n        this.dropLeadingWhitespace = true;\n      }\n    } else {\n      this.fail('expected block end in ' + name + ' statement');\n    }\n\n    return tok;\n  }\n\n  advanceAfterVariableEnd() {\n    var tok = this.nextToken();\n\n    if (tok && tok.type === lexer.TOKEN_VARIABLE_END) {\n      this.dropLeadingWhitespace = tok.value.charAt(\n        tok.value.length - this.tokens.tags.VARIABLE_END.length - 1\n      ) === '-';\n    } else {\n      this.pushToken(tok);\n      this.fail('expected variable end');\n    }\n  }\n\n  parseFor() {\n    var forTok = this.peekToken();\n    var node;\n    var endBlock;\n\n    if (this.skipSymbol('for')) {\n      node = new nodes.For(forTok.lineno, forTok.colno);\n      endBlock = 'endfor';\n    } else if (this.skipSymbol('asyncEach')) {\n      node = new nodes.AsyncEach(forTok.lineno, forTok.colno);\n      endBlock = 'endeach';\n    } else if (this.skipSymbol('asyncAll')) {\n      node = new nodes.AsyncAll(forTok.lineno, forTok.colno);\n      endBlock = 'endall';\n    } else {\n      this.fail('parseFor: expected for{Async}', forTok.lineno, forTok.colno);\n    }\n\n    node.name = this.parsePrimary();\n\n    if (!(node.name instanceof nodes.Symbol)) {\n      this.fail('parseFor: variable name expected for loop');\n    }\n\n    const type = this.peekToken().type;\n    if (type === lexer.TOKEN_COMMA) {\n      // key/value iteration\n      const key = node.name;\n      node.name = new nodes.Array(key.lineno, key.colno);\n      node.name.addChild(key);\n\n      while (this.skip(lexer.TOKEN_COMMA)) {\n        const prim = this.parsePrimary();\n        node.name.addChild(prim);\n      }\n    }\n\n    if (!this.skipSymbol('in')) {\n      this.fail('parseFor: expected \"in\" keyword for loop',\n        forTok.lineno,\n        forTok.colno);\n    }\n\n    node.arr = this.parseExpression();\n    this.advanceAfterBlockEnd(forTok.value);\n\n    node.body = this.parseUntilBlocks(endBlock, 'else');\n\n    if (this.skipSymbol('else')) {\n      this.advanceAfterBlockEnd('else');\n      node.else_ = this.parseUntilBlocks(endBlock);\n    }\n\n    this.advanceAfterBlockEnd();\n\n    return node;\n  }\n\n  parseMacro() {\n    const macroTok = this.peekToken();\n    if (!this.skipSymbol('macro')) {\n      this.fail('expected macro');\n    }\n\n    const name = this.parsePrimary(true);\n    const args = this.parseSignature();\n    const node = new nodes.Macro(macroTok.lineno, macroTok.colno, name, args);\n\n    this.advanceAfterBlockEnd(macroTok.value);\n    node.body = this.parseUntilBlocks('endmacro');\n    this.advanceAfterBlockEnd();\n\n    return node;\n  }\n\n  parseCall() {\n    // a call block is parsed as a normal FunCall, but with an added\n    // 'caller' kwarg which is a Caller node.\n    var callTok = this.peekToken();\n    if (!this.skipSymbol('call')) {\n      this.fail('expected call');\n    }\n\n    const callerArgs = this.parseSignature(true) || new nodes.NodeList();\n    const macroCall = this.parsePrimary();\n\n    this.advanceAfterBlockEnd(callTok.value);\n    const body = this.parseUntilBlocks('endcall');\n    this.advanceAfterBlockEnd();\n\n    const callerName = new nodes.Symbol(callTok.lineno,\n      callTok.colno,\n      'caller');\n    const callerNode = new nodes.Caller(callTok.lineno,\n      callTok.colno,\n      callerName,\n      callerArgs,\n      body);\n\n    // add the additional caller kwarg, adding kwargs if necessary\n    const args = macroCall.args.children;\n    if (!(args[args.length - 1] instanceof nodes.KeywordArgs)) {\n      args.push(new nodes.KeywordArgs());\n    }\n    const kwargs = args[args.length - 1];\n    kwargs.addChild(new nodes.Pair(callTok.lineno,\n      callTok.colno,\n      callerName,\n      callerNode));\n\n    return new nodes.Output(callTok.lineno,\n      callTok.colno,\n      [macroCall]);\n  }\n\n  parseWithContext() {\n    var tok = this.peekToken();\n\n    var withContext = null;\n\n    if (this.skipSymbol('with')) {\n      withContext = true;\n    } else if (this.skipSymbol('without')) {\n      withContext = false;\n    }\n\n    if (withContext !== null) {\n      if (!this.skipSymbol('context')) {\n        this.fail('parseFrom: expected context after with/without',\n          tok.lineno,\n          tok.colno);\n      }\n    }\n\n    return withContext;\n  }\n\n  parseImport() {\n    var importTok = this.peekToken();\n    if (!this.skipSymbol('import')) {\n      this.fail('parseImport: expected import',\n        importTok.lineno,\n        importTok.colno);\n    }\n\n    const template = this.parseExpression();\n\n    if (!this.skipSymbol('as')) {\n      this.fail('parseImport: expected \"as\" keyword',\n        importTok.lineno,\n        importTok.colno);\n    }\n\n    const target = this.parseExpression();\n    const withContext = this.parseWithContext();\n    const node = new nodes.Import(importTok.lineno,\n      importTok.colno,\n      template,\n      target,\n      withContext);\n\n    this.advanceAfterBlockEnd(importTok.value);\n\n    return node;\n  }\n\n  parseFrom() {\n    const fromTok = this.peekToken();\n    if (!this.skipSymbol('from')) {\n      this.fail('parseFrom: expected from');\n    }\n\n    const template = this.parseExpression();\n\n    if (!this.skipSymbol('import')) {\n      this.fail('parseFrom: expected import',\n        fromTok.lineno,\n        fromTok.colno);\n    }\n\n    const names = new nodes.NodeList();\n    let withContext;\n\n    while (1) { // eslint-disable-line no-constant-condition\n      const nextTok = this.peekToken();\n      if (nextTok.type === lexer.TOKEN_BLOCK_END) {\n        if (!names.children.length) {\n          this.fail('parseFrom: Expected at least one import name',\n            fromTok.lineno,\n            fromTok.colno);\n        }\n\n        // Since we are manually advancing past the block end,\n        // need to keep track of whitespace control (normally\n        // this is done in `advanceAfterBlockEnd`\n        if (nextTok.value.charAt(0) === '-') {\n          this.dropLeadingWhitespace = true;\n        }\n\n        this.nextToken();\n        break;\n      }\n\n      if (names.children.length > 0 && !this.skip(lexer.TOKEN_COMMA)) {\n        this.fail('parseFrom: expected comma',\n          fromTok.lineno,\n          fromTok.colno);\n      }\n\n      const name = this.parsePrimary();\n      if (name.value.charAt(0) === '_') {\n        this.fail('parseFrom: names starting with an underscore cannot be imported',\n          name.lineno,\n          name.colno);\n      }\n\n      if (this.skipSymbol('as')) {\n        const alias = this.parsePrimary();\n        names.addChild(new nodes.Pair(name.lineno,\n          name.colno,\n          name,\n          alias));\n      } else {\n        names.addChild(name);\n      }\n\n      withContext = this.parseWithContext();\n    }\n\n    return new nodes.FromImport(fromTok.lineno,\n      fromTok.colno,\n      template,\n      names,\n      withContext);\n  }\n\n  parseBlock() {\n    const tag = this.peekToken();\n    if (!this.skipSymbol('block')) {\n      this.fail('parseBlock: expected block', tag.lineno, tag.colno);\n    }\n\n    const node = new nodes.Block(tag.lineno, tag.colno);\n\n    node.name = this.parsePrimary();\n    if (!(node.name instanceof nodes.Symbol)) {\n      this.fail('parseBlock: variable name expected',\n        tag.lineno,\n        tag.colno);\n    }\n\n    this.advanceAfterBlockEnd(tag.value);\n\n    node.body = this.parseUntilBlocks('endblock');\n    this.skipSymbol('endblock');\n    this.skipSymbol(node.name.value);\n\n    const tok = this.peekToken();\n    if (!tok) {\n      this.fail('parseBlock: expected endblock, got end of file');\n    }\n\n    this.advanceAfterBlockEnd(tok.value);\n\n    return node;\n  }\n\n  parseExtends() {\n    const tagName = 'extends';\n    const tag = this.peekToken();\n    if (!this.skipSymbol(tagName)) {\n      this.fail('parseTemplateRef: expected ' + tagName);\n    }\n\n    const node = new nodes.Extends(tag.lineno, tag.colno);\n    node.template = this.parseExpression();\n\n    this.advanceAfterBlockEnd(tag.value);\n    return node;\n  }\n\n  parseInclude() {\n    const tagName = 'include';\n    const tag = this.peekToken();\n    if (!this.skipSymbol(tagName)) {\n      this.fail('parseInclude: expected ' + tagName);\n    }\n\n    const node = new nodes.Include(tag.lineno, tag.colno);\n    node.template = this.parseExpression();\n\n    if (this.skipSymbol('ignore') && this.skipSymbol('missing')) {\n      node.ignoreMissing = true;\n    }\n\n    this.advanceAfterBlockEnd(tag.value);\n    return node;\n  }\n\n  parseIf() {\n    const tag = this.peekToken();\n    let node;\n\n    if (this.skipSymbol('if') || this.skipSymbol('elif') || this.skipSymbol('elseif')) {\n      node = new nodes.If(tag.lineno, tag.colno);\n    } else if (this.skipSymbol('ifAsync')) {\n      node = new nodes.IfAsync(tag.lineno, tag.colno);\n    } else {\n      this.fail('parseIf: expected if, elif, or elseif',\n        tag.lineno,\n        tag.colno);\n    }\n\n    node.cond = this.parseExpression();\n    this.advanceAfterBlockEnd(tag.value);\n\n    node.body = this.parseUntilBlocks('elif', 'elseif', 'else', 'endif');\n    const tok = this.peekToken();\n\n    switch (tok && tok.value) {\n      case 'elseif':\n      case 'elif':\n        node.else_ = this.parseIf();\n        break;\n      case 'else':\n        this.advanceAfterBlockEnd();\n        node.else_ = this.parseUntilBlocks('endif');\n        this.advanceAfterBlockEnd();\n        break;\n      case 'endif':\n        node.else_ = null;\n        this.advanceAfterBlockEnd();\n        break;\n      default:\n        this.fail('parseIf: expected elif, else, or endif, got end of file');\n    }\n\n    return node;\n  }\n\n  parseSet() {\n    const tag = this.peekToken();\n    if (!this.skipSymbol('set')) {\n      this.fail('parseSet: expected set', tag.lineno, tag.colno);\n    }\n\n    const node = new nodes.Set(tag.lineno, tag.colno, []);\n\n    let target;\n    while ((target = this.parsePrimary())) {\n      node.targets.push(target);\n\n      if (!this.skip(lexer.TOKEN_COMMA)) {\n        break;\n      }\n    }\n\n    if (!this.skipValue(lexer.TOKEN_OPERATOR, '=')) {\n      if (!this.skip(lexer.TOKEN_BLOCK_END)) {\n        this.fail('parseSet: expected = or block end in set tag',\n          tag.lineno,\n          tag.colno);\n      } else {\n        node.body = new nodes.Capture(\n          tag.lineno,\n          tag.colno,\n          this.parseUntilBlocks('endset')\n        );\n        node.value = null;\n        this.advanceAfterBlockEnd();\n      }\n    } else {\n      node.value = this.parseExpression();\n      this.advanceAfterBlockEnd(tag.value);\n    }\n\n    return node;\n  }\n\n  parseSwitch() {\n    /*\n     * Store the tag names in variables in case someone ever wants to\n     * customize this.\n     */\n    const switchStart = 'switch';\n    const switchEnd = 'endswitch';\n    const caseStart = 'case';\n    const caseDefault = 'default';\n\n    // Get the switch tag.\n    const tag = this.peekToken();\n\n    // fail early if we get some unexpected tag.\n    if (\n      !this.skipSymbol(switchStart)\n      && !this.skipSymbol(caseStart)\n      && !this.skipSymbol(caseDefault)\n    ) {\n      this.fail('parseSwitch: expected \"switch,\" \"case\" or \"default\"', tag.lineno, tag.colno);\n    }\n\n    // parse the switch expression\n    const expr = this.parseExpression();\n\n    // advance until a start of a case, a default case or an endswitch.\n    this.advanceAfterBlockEnd(switchStart);\n    this.parseUntilBlocks(caseStart, caseDefault, switchEnd);\n\n    // this is the first case. it could also be an endswitch, we'll check.\n    let tok = this.peekToken();\n\n    // create new variables for our cases and default case.\n    const cases = [];\n    let defaultCase;\n\n    // while we're dealing with new cases nodes...\n    do {\n      // skip the start symbol and get the case expression\n      this.skipSymbol(caseStart);\n      const cond = this.parseExpression();\n      this.advanceAfterBlockEnd(switchStart);\n      // get the body of the case node and add it to the array of cases.\n      const body = this.parseUntilBlocks(caseStart, caseDefault, switchEnd);\n      cases.push(new nodes.Case(tok.line, tok.col, cond, body));\n      // get our next case\n      tok = this.peekToken();\n    } while (tok && tok.value === caseStart);\n\n    // we either have a default case or a switch end.\n    switch (tok.value) {\n      case caseDefault:\n        this.advanceAfterBlockEnd();\n        defaultCase = this.parseUntilBlocks(switchEnd);\n        this.advanceAfterBlockEnd();\n        break;\n      case switchEnd:\n        this.advanceAfterBlockEnd();\n        break;\n      default:\n        // otherwise bail because EOF\n        this.fail('parseSwitch: expected \"case,\" \"default\" or \"endswitch,\" got EOF.');\n    }\n\n    // and return the switch node.\n    return new nodes.Switch(tag.lineno, tag.colno, expr, cases, defaultCase);\n  }\n\n  parseStatement() {\n    var tok = this.peekToken();\n    var node;\n\n    if (tok.type !== lexer.TOKEN_SYMBOL) {\n      this.fail('tag name expected', tok.lineno, tok.colno);\n    }\n\n    if (this.breakOnBlocks &&\n      lib.indexOf(this.breakOnBlocks, tok.value) !== -1) {\n      return null;\n    }\n\n    switch (tok.value) {\n      case 'raw':\n        return this.parseRaw();\n      case 'verbatim':\n        return this.parseRaw('verbatim');\n      case 'if':\n      case 'ifAsync':\n        return this.parseIf();\n      case 'for':\n      case 'asyncEach':\n      case 'asyncAll':\n        return this.parseFor();\n      case 'block':\n        return this.parseBlock();\n      case 'extends':\n        return this.parseExtends();\n      case 'include':\n        return this.parseInclude();\n      case 'set':\n        return this.parseSet();\n      case 'macro':\n        return this.parseMacro();\n      case 'call':\n        return this.parseCall();\n      case 'import':\n        return this.parseImport();\n      case 'from':\n        return this.parseFrom();\n      case 'filter':\n        return this.parseFilterStatement();\n      case 'switch':\n        return this.parseSwitch();\n      default:\n        if (this.extensions.length) {\n          for (let i = 0; i < this.extensions.length; i++) {\n            const ext = this.extensions[i];\n            if (lib.indexOf(ext.tags || [], tok.value) !== -1) {\n              return ext.parse(this, nodes, lexer);\n            }\n          }\n        }\n        this.fail('unknown block tag: ' + tok.value, tok.lineno, tok.colno);\n    }\n\n    return node;\n  }\n\n  parseRaw(tagName) {\n    tagName = tagName || 'raw';\n    const endTagName = 'end' + tagName;\n    // Look for upcoming raw blocks (ignore all other kinds of blocks)\n    const rawBlockRegex = new RegExp('([\\\\s\\\\S]*?){%\\\\s*(' + tagName + '|' + endTagName + ')\\\\s*(?=%})%}');\n    let rawLevel = 1;\n    let str = '';\n    let matches = null;\n\n    // Skip opening raw token\n    // Keep this token to track line and column numbers\n    const begun = this.advanceAfterBlockEnd();\n\n    // Exit when there's nothing to match\n    // or when we've found the matching \"endraw\" block\n    while ((matches = this.tokens._extractRegex(rawBlockRegex)) && rawLevel > 0) {\n      const all = matches[0];\n      const pre = matches[1];\n      const blockName = matches[2];\n\n      // Adjust rawlevel\n      if (blockName === tagName) {\n        rawLevel += 1;\n      } else if (blockName === endTagName) {\n        rawLevel -= 1;\n      }\n\n      // Add to str\n      if (rawLevel === 0) {\n        // We want to exclude the last \"endraw\"\n        str += pre;\n        // Move tokenizer to beginning of endraw block\n        this.tokens.backN(all.length - pre.length);\n      } else {\n        str += all;\n      }\n    }\n\n    return new nodes.Output(\n      begun.lineno,\n      begun.colno,\n      [new nodes.TemplateData(begun.lineno, begun.colno, str)]\n    );\n  }\n\n  parsePostfix(node) {\n    let lookup;\n    let tok = this.peekToken();\n\n    while (tok) {\n      if (tok.type === lexer.TOKEN_LEFT_PAREN) {\n        // Function call\n        node = new nodes.FunCall(tok.lineno,\n          tok.colno,\n          node,\n          this.parseSignature());\n      } else if (tok.type === lexer.TOKEN_LEFT_BRACKET) {\n        // Reference\n        lookup = this.parseAggregate();\n        if (lookup.children.length > 1) {\n          this.fail('invalid index');\n        }\n\n        node = new nodes.LookupVal(tok.lineno,\n          tok.colno,\n          node,\n          lookup.children[0]);\n      } else if (tok.type === lexer.TOKEN_OPERATOR && tok.value === '.') {\n        // Reference\n        this.nextToken();\n        const val = this.nextToken();\n\n        if (val.type !== lexer.TOKEN_SYMBOL) {\n          this.fail('expected name as lookup value, got ' + val.value,\n            val.lineno,\n            val.colno);\n        }\n\n        // Make a literal string because it's not a variable\n        // reference\n        lookup = new nodes.Literal(val.lineno,\n          val.colno,\n          val.value);\n\n        node = new nodes.LookupVal(tok.lineno,\n          tok.colno,\n          node,\n          lookup);\n      } else {\n        break;\n      }\n\n      tok = this.peekToken();\n    }\n\n    return node;\n  }\n\n  parseExpression() {\n    var node = this.parseInlineIf();\n    return node;\n  }\n\n  parseInlineIf() {\n    let node = this.parseOr();\n    if (this.skipSymbol('if')) {\n      const condNode = this.parseOr();\n      const bodyNode = node;\n      node = new nodes.InlineIf(node.lineno, node.colno);\n      node.body = bodyNode;\n      node.cond = condNode;\n      if (this.skipSymbol('else')) {\n        node.else_ = this.parseOr();\n      } else {\n        node.else_ = null;\n      }\n    }\n\n    return node;\n  }\n\n  parseOr() {\n    let node = this.parseAnd();\n    while (this.skipSymbol('or')) {\n      const node2 = this.parseAnd();\n      node = new nodes.Or(node.lineno,\n        node.colno,\n        node,\n        node2);\n    }\n    return node;\n  }\n\n  parseAnd() {\n    let node = this.parseNot();\n    while (this.skipSymbol('and')) {\n      const node2 = this.parseNot();\n      node = new nodes.And(node.lineno,\n        node.colno,\n        node,\n        node2);\n    }\n    return node;\n  }\n\n  parseNot() {\n    const tok = this.peekToken();\n    if (this.skipSymbol('not')) {\n      return new nodes.Not(tok.lineno,\n        tok.colno,\n        this.parseNot());\n    }\n    return this.parseIn();\n  }\n\n  parseIn() {\n    let node = this.parseIs();\n    while (1) { // eslint-disable-line no-constant-condition\n      // check if the next token is 'not'\n      const tok = this.nextToken();\n      if (!tok) {\n        break;\n      }\n      const invert = tok.type === lexer.TOKEN_SYMBOL && tok.value === 'not';\n      // if it wasn't 'not', put it back\n      if (!invert) {\n        this.pushToken(tok);\n      }\n      if (this.skipSymbol('in')) {\n        const node2 = this.parseIs();\n        node = new nodes.In(node.lineno,\n          node.colno,\n          node,\n          node2);\n        if (invert) {\n          node = new nodes.Not(node.lineno,\n            node.colno,\n            node);\n        }\n      } else {\n        // if we'd found a 'not' but this wasn't an 'in', put back the 'not'\n        if (invert) {\n          this.pushToken(tok);\n        }\n        break;\n      }\n    }\n    return node;\n  }\n\n  // I put this right after \"in\" in the operator precedence stack. That can\n  // obviously be changed to be closer to Jinja.\n  parseIs() {\n    let node = this.parseCompare();\n    // look for an is\n    if (this.skipSymbol('is')) {\n      // look for a not\n      const not = this.skipSymbol('not');\n      // get the next node\n      const node2 = this.parseCompare();\n      // create an Is node using the next node and the info from our Is node.\n      node = new nodes.Is(node.lineno, node.colno, node, node2);\n      // if we have a Not, create a Not node from our Is node.\n      if (not) {\n        node = new nodes.Not(node.lineno, node.colno, node);\n      }\n    }\n    // return the node.\n    return node;\n  }\n\n  parseCompare() {\n    const compareOps = ['==', '===', '!=', '!==', '<', '>', '<=', '>='];\n    const expr = this.parseConcat();\n    const ops = [];\n\n    while (1) { // eslint-disable-line no-constant-condition\n      const tok = this.nextToken();\n\n      if (!tok) {\n        break;\n      } else if (compareOps.indexOf(tok.value) !== -1) {\n        ops.push(new nodes.CompareOperand(tok.lineno,\n          tok.colno,\n          this.parseConcat(),\n          tok.value));\n      } else {\n        this.pushToken(tok);\n        break;\n      }\n    }\n\n    if (ops.length) {\n      return new nodes.Compare(ops[0].lineno,\n        ops[0].colno,\n        expr,\n        ops);\n    } else {\n      return expr;\n    }\n  }\n\n  // finds the '~' for string concatenation\n  parseConcat() {\n    let node = this.parseAdd();\n    while (this.skipValue(lexer.TOKEN_TILDE, '~')) {\n      const node2 = this.parseAdd();\n      node = new nodes.Concat(node.lineno,\n        node.colno,\n        node,\n        node2);\n    }\n    return node;\n  }\n\n  parseAdd() {\n    let node = this.parseSub();\n    while (this.skipValue(lexer.TOKEN_OPERATOR, '+')) {\n      const node2 = this.parseSub();\n      node = new nodes.Add(node.lineno,\n        node.colno,\n        node,\n        node2);\n    }\n    return node;\n  }\n\n  parseSub() {\n    let node = this.parseMul();\n    while (this.skipValue(lexer.TOKEN_OPERATOR, '-')) {\n      const node2 = this.parseMul();\n      node = new nodes.Sub(node.lineno,\n        node.colno,\n        node,\n        node2);\n    }\n    return node;\n  }\n\n  parseMul() {\n    let node = this.parseDiv();\n    while (this.skipValue(lexer.TOKEN_OPERATOR, '*')) {\n      const node2 = this.parseDiv();\n      node = new nodes.Mul(node.lineno,\n        node.colno,\n        node,\n        node2);\n    }\n    return node;\n  }\n\n  parseDiv() {\n    let node = this.parseFloorDiv();\n    while (this.skipValue(lexer.TOKEN_OPERATOR, '/')) {\n      const node2 = this.parseFloorDiv();\n      node = new nodes.Div(node.lineno,\n        node.colno,\n        node,\n        node2);\n    }\n    return node;\n  }\n\n  parseFloorDiv() {\n    let node = this.parseMod();\n    while (this.skipValue(lexer.TOKEN_OPERATOR, '//')) {\n      const node2 = this.parseMod();\n      node = new nodes.FloorDiv(node.lineno,\n        node.colno,\n        node,\n        node2);\n    }\n    return node;\n  }\n\n  parseMod() {\n    let node = this.parsePow();\n    while (this.skipValue(lexer.TOKEN_OPERATOR, '%')) {\n      const node2 = this.parsePow();\n      node = new nodes.Mod(node.lineno,\n        node.colno,\n        node,\n        node2);\n    }\n    return node;\n  }\n\n  parsePow() {\n    let node = this.parseUnary();\n    while (this.skipValue(lexer.TOKEN_OPERATOR, '**')) {\n      const node2 = this.parseUnary();\n      node = new nodes.Pow(node.lineno,\n        node.colno,\n        node,\n        node2);\n    }\n    return node;\n  }\n\n  parseUnary(noFilters) {\n    const tok = this.peekToken();\n    let node;\n\n    if (this.skipValue(lexer.TOKEN_OPERATOR, '-')) {\n      node = new nodes.Neg(tok.lineno,\n        tok.colno,\n        this.parseUnary(true));\n    } else if (this.skipValue(lexer.TOKEN_OPERATOR, '+')) {\n      node = new nodes.Pos(tok.lineno,\n        tok.colno,\n        this.parseUnary(true));\n    } else {\n      node = this.parsePrimary();\n    }\n\n    if (!noFilters) {\n      node = this.parseFilter(node);\n    }\n\n    return node;\n  }\n\n  parsePrimary(noPostfix) {\n    const tok = this.nextToken();\n    let val;\n    let node = null;\n\n    if (!tok) {\n      this.fail('expected expression, got end of file');\n    } else if (tok.type === lexer.TOKEN_STRING) {\n      val = tok.value;\n    } else if (tok.type === lexer.TOKEN_INT) {\n      val = parseInt(tok.value, 10);\n    } else if (tok.type === lexer.TOKEN_FLOAT) {\n      val = parseFloat(tok.value);\n    } else if (tok.type === lexer.TOKEN_BOOLEAN) {\n      if (tok.value === 'true') {\n        val = true;\n      } else if (tok.value === 'false') {\n        val = false;\n      } else {\n        this.fail('invalid boolean: ' + tok.value,\n          tok.lineno,\n          tok.colno);\n      }\n    } else if (tok.type === lexer.TOKEN_NONE) {\n      val = null;\n    } else if (tok.type === lexer.TOKEN_REGEX) {\n      val = new RegExp(tok.value.body, tok.value.flags);\n    }\n\n    if (val !== undefined) {\n      node = new nodes.Literal(tok.lineno, tok.colno, val);\n    } else if (tok.type === lexer.TOKEN_SYMBOL) {\n      node = new nodes.Symbol(tok.lineno, tok.colno, tok.value);\n    } else {\n      // See if it's an aggregate type, we need to push the\n      // current delimiter token back on\n      this.pushToken(tok);\n      node = this.parseAggregate();\n    }\n\n    if (!noPostfix) {\n      node = this.parsePostfix(node);\n    }\n\n    if (node) {\n      return node;\n    } else {\n      throw this.error(`unexpected token: ${tok.value}`, tok.lineno, tok.colno);\n    }\n  }\n\n  parseFilterName() {\n    const tok = this.expect(lexer.TOKEN_SYMBOL);\n    let name = tok.value;\n\n    while (this.skipValue(lexer.TOKEN_OPERATOR, '.')) {\n      name += '.' + this.expect(lexer.TOKEN_SYMBOL).value;\n    }\n\n    return new nodes.Symbol(tok.lineno, tok.colno, name);\n  }\n\n  parseFilterArgs(node) {\n    if (this.peekToken().type === lexer.TOKEN_LEFT_PAREN) {\n      // Get a FunCall node and add the parameters to the\n      // filter\n      const call = this.parsePostfix(node);\n      return call.args.children;\n    }\n    return [];\n  }\n\n  parseFilter(node) {\n    while (this.skip(lexer.TOKEN_PIPE)) {\n      const name = this.parseFilterName();\n\n      node = new nodes.Filter(\n        name.lineno,\n        name.colno,\n        name,\n        new nodes.NodeList(\n          name.lineno,\n          name.colno,\n          [node].concat(this.parseFilterArgs(node))\n        )\n      );\n    }\n\n    return node;\n  }\n\n  parseFilterStatement() {\n    var filterTok = this.peekToken();\n    if (!this.skipSymbol('filter')) {\n      this.fail('parseFilterStatement: expected filter');\n    }\n\n    const name = this.parseFilterName();\n    const args = this.parseFilterArgs(name);\n\n    this.advanceAfterBlockEnd(filterTok.value);\n    const body = new nodes.Capture(\n      name.lineno,\n      name.colno,\n      this.parseUntilBlocks('endfilter')\n    );\n    this.advanceAfterBlockEnd();\n\n    const node = new nodes.Filter(\n      name.lineno,\n      name.colno,\n      name,\n      new nodes.NodeList(\n        name.lineno,\n        name.colno,\n        [body].concat(args)\n      )\n    );\n\n    return new nodes.Output(\n      name.lineno,\n      name.colno,\n      [node]\n    );\n  }\n\n  parseAggregate() {\n    var tok = this.nextToken();\n    var node;\n\n    switch (tok.type) {\n      case lexer.TOKEN_LEFT_PAREN:\n        node = new nodes.Group(tok.lineno, tok.colno);\n        break;\n      case lexer.TOKEN_LEFT_BRACKET:\n        node = new nodes.Array(tok.lineno, tok.colno);\n        break;\n      case lexer.TOKEN_LEFT_CURLY:\n        node = new nodes.Dict(tok.lineno, tok.colno);\n        break;\n      default:\n        return null;\n    }\n\n    while (1) { // eslint-disable-line no-constant-condition\n      const type = this.peekToken().type;\n      if (type === lexer.TOKEN_RIGHT_PAREN ||\n        type === lexer.TOKEN_RIGHT_BRACKET ||\n        type === lexer.TOKEN_RIGHT_CURLY) {\n        this.nextToken();\n        break;\n      }\n\n      if (node.children.length > 0) {\n        if (!this.skip(lexer.TOKEN_COMMA)) {\n          this.fail('parseAggregate: expected comma after expression',\n            tok.lineno,\n            tok.colno);\n        }\n      }\n\n      if (node instanceof nodes.Dict) {\n        // TODO: check for errors\n        const key = this.parsePrimary();\n\n        // We expect a key/value pair for dicts, separated by a\n        // colon\n        if (!this.skip(lexer.TOKEN_COLON)) {\n          this.fail('parseAggregate: expected colon after dict key',\n            tok.lineno,\n            tok.colno);\n        }\n\n        // TODO: check for errors\n        const value = this.parseExpression();\n        node.addChild(new nodes.Pair(key.lineno,\n          key.colno,\n          key,\n          value));\n      } else {\n        // TODO: check for errors\n        const expr = this.parseExpression();\n        node.addChild(expr);\n      }\n    }\n\n    return node;\n  }\n\n  parseSignature(tolerant, noParens) {\n    let tok = this.peekToken();\n    if (!noParens && tok.type !== lexer.TOKEN_LEFT_PAREN) {\n      if (tolerant) {\n        return null;\n      } else {\n        this.fail('expected arguments', tok.lineno, tok.colno);\n      }\n    }\n\n    if (tok.type === lexer.TOKEN_LEFT_PAREN) {\n      tok = this.nextToken();\n    }\n\n    const args = new nodes.NodeList(tok.lineno, tok.colno);\n    const kwargs = new nodes.KeywordArgs(tok.lineno, tok.colno);\n    let checkComma = false;\n\n    while (1) { // eslint-disable-line no-constant-condition\n      tok = this.peekToken();\n      if (!noParens && tok.type === lexer.TOKEN_RIGHT_PAREN) {\n        this.nextToken();\n        break;\n      } else if (noParens && tok.type === lexer.TOKEN_BLOCK_END) {\n        break;\n      }\n\n      if (checkComma && !this.skip(lexer.TOKEN_COMMA)) {\n        this.fail('parseSignature: expected comma after expression',\n          tok.lineno,\n          tok.colno);\n      } else {\n        const arg = this.parseExpression();\n\n        if (this.skipValue(lexer.TOKEN_OPERATOR, '=')) {\n          kwargs.addChild(\n            new nodes.Pair(arg.lineno,\n              arg.colno,\n              arg,\n              this.parseExpression())\n          );\n        } else {\n          args.addChild(arg);\n        }\n      }\n\n      checkComma = true;\n    }\n\n    if (kwargs.children.length) {\n      args.addChild(kwargs);\n    }\n\n    return args;\n  }\n\n  parseUntilBlocks(...blockNames) {\n    const prev = this.breakOnBlocks;\n    this.breakOnBlocks = blockNames;\n\n    const ret = this.parse();\n\n    this.breakOnBlocks = prev;\n    return ret;\n  }\n\n  parseNodes() {\n    let tok;\n    const buf = [];\n\n    while ((tok = this.nextToken())) {\n      if (tok.type === lexer.TOKEN_DATA) {\n        let data = tok.value;\n        const nextToken = this.peekToken();\n        const nextVal = nextToken && nextToken.value;\n\n        // If the last token has \"-\" we need to trim the\n        // leading whitespace of the data. This is marked with\n        // the `dropLeadingWhitespace` variable.\n        if (this.dropLeadingWhitespace) {\n          // TODO: this could be optimized (don't use regex)\n          data = data.replace(/^\\s*/, '');\n          this.dropLeadingWhitespace = false;\n        }\n\n        // Same for the succeeding block start token\n        if (nextToken &&\n          ((nextToken.type === lexer.TOKEN_BLOCK_START &&\n          nextVal.charAt(nextVal.length - 1) === '-') ||\n          (nextToken.type === lexer.TOKEN_VARIABLE_START &&\n          nextVal.charAt(this.tokens.tags.VARIABLE_START.length)\n          === '-') ||\n          (nextToken.type === lexer.TOKEN_COMMENT &&\n          nextVal.charAt(this.tokens.tags.COMMENT_START.length)\n          === '-'))) {\n          // TODO: this could be optimized (don't use regex)\n          data = data.replace(/\\s*$/, '');\n        }\n\n        buf.push(new nodes.Output(tok.lineno,\n          tok.colno,\n          [new nodes.TemplateData(tok.lineno,\n            tok.colno,\n            data)]));\n      } else if (tok.type === lexer.TOKEN_BLOCK_START) {\n        this.dropLeadingWhitespace = false;\n        const n = this.parseStatement();\n        if (!n) {\n          break;\n        }\n        buf.push(n);\n      } else if (tok.type === lexer.TOKEN_VARIABLE_START) {\n        const e = this.parseExpression();\n        this.dropLeadingWhitespace = false;\n        this.advanceAfterVariableEnd();\n        buf.push(new nodes.Output(tok.lineno, tok.colno, [e]));\n      } else if (tok.type === lexer.TOKEN_COMMENT) {\n        this.dropLeadingWhitespace = tok.value.charAt(\n          tok.value.length - this.tokens.tags.COMMENT_END.length - 1\n        ) === '-';\n      } else {\n        // Ignore comments, otherwise this should be an error\n        this.fail('Unexpected token at top-level: ' +\n          tok.type, tok.lineno, tok.colno);\n      }\n    }\n\n    return buf;\n  }\n\n  parse() {\n    return new nodes.NodeList(0, 0, this.parseNodes());\n  }\n\n  parseAsRoot() {\n    return new nodes.Root(0, 0, this.parseNodes());\n  }\n}\n\n// var util = require('util');\n\n// var l = lexer.lex('{%- if x -%}\\n hello {% endif %}');\n// var t;\n// while((t = l.nextToken())) {\n//     console.log(util.inspect(t));\n// }\n\n// var p = new Parser(lexer.lex('hello {% filter title %}' +\n//                              'Hello madam how are you' +\n//                              '{% endfilter %}'));\n// var n = p.parseAsRoot();\n// nodes.printNodes(n);\n\nmodule.exports = {\n  parse(src, extensions, opts) {\n    var p = new Parser(lexer.lex(src, opts));\n    if (extensions !== undefined) {\n      p.extensions = extensions;\n    }\n    return p.parseAsRoot();\n  },\n  Parser: Parser\n};\n\n\n\n// WEBPACK FOOTER //\n// ./nunjucks/src/parser.js","'use strict';\n\nconst lib = require('./lib');\n\nlet whitespaceChars = ' \\n\\t\\r\\u00A0';\nlet delimChars = '()[]{}%*-+~/#,:|.<>=!';\nlet intChars = '0123456789';\n\nlet BLOCK_START = '{%';\nlet BLOCK_END = '%}';\nlet VARIABLE_START = '{{';\nlet VARIABLE_END = '}}';\nlet COMMENT_START = '{#';\nlet COMMENT_END = '#}';\n\nlet TOKEN_STRING = 'string';\nlet TOKEN_WHITESPACE = 'whitespace';\nlet TOKEN_DATA = 'data';\nlet TOKEN_BLOCK_START = 'block-start';\nlet TOKEN_BLOCK_END = 'block-end';\nlet TOKEN_VARIABLE_START = 'variable-start';\nlet TOKEN_VARIABLE_END = 'variable-end';\nlet TOKEN_COMMENT = 'comment';\nlet TOKEN_LEFT_PAREN = 'left-paren';\nlet TOKEN_RIGHT_PAREN = 'right-paren';\nlet TOKEN_LEFT_BRACKET = 'left-bracket';\nlet TOKEN_RIGHT_BRACKET = 'right-bracket';\nlet TOKEN_LEFT_CURLY = 'left-curly';\nlet TOKEN_RIGHT_CURLY = 'right-curly';\nlet TOKEN_OPERATOR = 'operator';\nlet TOKEN_COMMA = 'comma';\nlet TOKEN_COLON = 'colon';\nlet TOKEN_TILDE = 'tilde';\nlet TOKEN_PIPE = 'pipe';\nlet TOKEN_INT = 'int';\nlet TOKEN_FLOAT = 'float';\nlet TOKEN_BOOLEAN = 'boolean';\nlet TOKEN_NONE = 'none';\nlet TOKEN_SYMBOL = 'symbol';\nlet TOKEN_SPECIAL = 'special';\nlet TOKEN_REGEX = 'regex';\n\nfunction token(type, value, lineno, colno) {\n  return {\n    type: type,\n    value: value,\n    lineno: lineno,\n    colno: colno\n  };\n}\n\nclass Tokenizer {\n  constructor(str, opts) {\n    this.str = str;\n    this.index = 0;\n    this.len = str.length;\n    this.lineno = 0;\n    this.colno = 0;\n\n    this.in_code = false;\n\n    opts = opts || {};\n\n    let tags = opts.tags || {};\n    this.tags = {\n      BLOCK_START: tags.blockStart || BLOCK_START,\n      BLOCK_END: tags.blockEnd || BLOCK_END,\n      VARIABLE_START: tags.variableStart || VARIABLE_START,\n      VARIABLE_END: tags.variableEnd || VARIABLE_END,\n      COMMENT_START: tags.commentStart || COMMENT_START,\n      COMMENT_END: tags.commentEnd || COMMENT_END\n    };\n\n    this.trimBlocks = !!opts.trimBlocks;\n    this.lstripBlocks = !!opts.lstripBlocks;\n  }\n\n  nextToken() {\n    let lineno = this.lineno;\n    let colno = this.colno;\n    let tok;\n\n    if (this.in_code) {\n      // Otherwise, if we are in a block parse it as code\n      let cur = this.current();\n\n      if (this.isFinished()) {\n        // We have nothing else to parse\n        return null;\n      } else if (cur === '\"' || cur === '\\'') {\n        // We've hit a string\n        return token(TOKEN_STRING, this._parseString(cur), lineno, colno);\n      } else if ((tok = this._extract(whitespaceChars))) {\n        // We hit some whitespace\n        return token(TOKEN_WHITESPACE, tok, lineno, colno);\n      } else if ((tok = this._extractString(this.tags.BLOCK_END)) ||\n        (tok = this._extractString('-' + this.tags.BLOCK_END))) {\n        // Special check for the block end tag\n        //\n        // It is a requirement that start and end tags are composed of\n        // delimiter characters (%{}[] etc), and our code always\n        // breaks on delimiters so we can assume the token parsing\n        // doesn't consume these elsewhere\n        this.in_code = false;\n        if (this.trimBlocks) {\n          cur = this.current();\n          if (cur === '\\n') {\n            // Skip newline\n            this.forward();\n          } else if (cur === '\\r') {\n            // Skip CRLF newline\n            this.forward();\n            cur = this.current();\n            if (cur === '\\n') {\n              this.forward();\n            } else {\n              // Was not a CRLF, so go back\n              this.back();\n            }\n          }\n        }\n        return token(TOKEN_BLOCK_END, tok, lineno, colno);\n      } else if ((tok = this._extractString(this.tags.VARIABLE_END)) ||\n        (tok = this._extractString('-' + this.tags.VARIABLE_END))) {\n        // Special check for variable end tag (see above)\n        this.in_code = false;\n        return token(TOKEN_VARIABLE_END, tok, lineno, colno);\n      } else if (cur === 'r' && this.str.charAt(this.index + 1) === '/') {\n        // Skip past 'r/'.\n        this.forwardN(2);\n\n        // Extract until the end of the regex -- / ends it, \\/ does not.\n        let regexBody = '';\n        while (!this.isFinished()) {\n          if (this.current() === '/' && this.previous() !== '\\\\') {\n            this.forward();\n            break;\n          } else {\n            regexBody += this.current();\n            this.forward();\n          }\n        }\n\n        // Check for flags.\n        // The possible flags are according to https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/RegExp)\n        let POSSIBLE_FLAGS = ['g', 'i', 'm', 'y'];\n        let regexFlags = '';\n        while (!this.isFinished()) {\n          let isCurrentAFlag = POSSIBLE_FLAGS.indexOf(this.current()) !== -1;\n          if (isCurrentAFlag) {\n            regexFlags += this.current();\n            this.forward();\n          } else {\n            break;\n          }\n        }\n\n        return token(TOKEN_REGEX, {\n          body: regexBody,\n          flags: regexFlags\n        }, lineno, colno);\n      } else if (delimChars.indexOf(cur) !== -1) {\n        // We've hit a delimiter (a special char like a bracket)\n        this.forward();\n        let complexOps = ['==', '===', '!=', '!==', '<=', '>=', '//', '**'];\n        let curComplex = cur + this.current();\n        let type;\n\n        if (lib.indexOf(complexOps, curComplex) !== -1) {\n          this.forward();\n          cur = curComplex;\n\n          // See if this is a strict equality/inequality comparator\n          if (lib.indexOf(complexOps, curComplex + this.current()) !== -1) {\n            cur = curComplex + this.current();\n            this.forward();\n          }\n        }\n\n        switch (cur) {\n          case '(':\n            type = TOKEN_LEFT_PAREN;\n            break;\n          case ')':\n            type = TOKEN_RIGHT_PAREN;\n            break;\n          case '[':\n            type = TOKEN_LEFT_BRACKET;\n            break;\n          case ']':\n            type = TOKEN_RIGHT_BRACKET;\n            break;\n          case '{':\n            type = TOKEN_LEFT_CURLY;\n            break;\n          case '}':\n            type = TOKEN_RIGHT_CURLY;\n            break;\n          case ',':\n            type = TOKEN_COMMA;\n            break;\n          case ':':\n            type = TOKEN_COLON;\n            break;\n          case '~':\n            type = TOKEN_TILDE;\n            break;\n          case '|':\n            type = TOKEN_PIPE;\n            break;\n          default:\n            type = TOKEN_OPERATOR;\n        }\n\n        return token(type, cur, lineno, colno);\n      } else {\n        // We are not at whitespace or a delimiter, so extract the\n        // text and parse it\n        tok = this._extractUntil(whitespaceChars + delimChars);\n\n        if (tok.match(/^[-+]?[0-9]+$/)) {\n          if (this.current() === '.') {\n            this.forward();\n            let dec = this._extract(intChars);\n            return token(TOKEN_FLOAT, tok + '.' + dec, lineno, colno);\n          } else {\n            return token(TOKEN_INT, tok, lineno, colno);\n          }\n        } else if (tok.match(/^(true|false)$/)) {\n          return token(TOKEN_BOOLEAN, tok, lineno, colno);\n        } else if (tok === 'none') {\n          return token(TOKEN_NONE, tok, lineno, colno);\n        /*\n         * Added to make the test `null is null` evaluate truthily.\n         * Otherwise, Nunjucks will look up null in the context and\n         * return `undefined`, which is not what we want. This *may* have\n         * consequences is someone is using null in their templates as a\n         * variable.\n         */\n        } else if (tok === 'null') {\n          return token(TOKEN_NONE, tok, lineno, colno);\n        } else if (tok) {\n          return token(TOKEN_SYMBOL, tok, lineno, colno);\n        } else {\n          throw new Error('Unexpected value while parsing: ' + tok);\n        }\n      }\n    } else {\n      // Parse out the template text, breaking on tag\n      // delimiters because we need to look for block/variable start\n      // tags (don't use the full delimChars for optimization)\n      let beginChars = (this.tags.BLOCK_START.charAt(0) +\n      this.tags.VARIABLE_START.charAt(0) +\n      this.tags.COMMENT_START.charAt(0) +\n      this.tags.COMMENT_END.charAt(0));\n\n      if (this.isFinished()) {\n        return null;\n      } else if ((tok = this._extractString(this.tags.BLOCK_START + '-')) ||\n        (tok = this._extractString(this.tags.BLOCK_START))) {\n        this.in_code = true;\n        return token(TOKEN_BLOCK_START, tok, lineno, colno);\n      } else if ((tok = this._extractString(this.tags.VARIABLE_START + '-')) ||\n        (tok = this._extractString(this.tags.VARIABLE_START))) {\n        this.in_code = true;\n        return token(TOKEN_VARIABLE_START, tok, lineno, colno);\n      } else {\n        tok = '';\n        let data;\n        let inComment = false;\n\n        if (this._matches(this.tags.COMMENT_START)) {\n          inComment = true;\n          tok = this._extractString(this.tags.COMMENT_START);\n        }\n\n        // Continually consume text, breaking on the tag delimiter\n        // characters and checking to see if it's a start tag.\n        //\n        // We could hit the end of the template in the middle of\n        // our looping, so check for the null return value from\n        // _extractUntil\n        while ((data = this._extractUntil(beginChars)) !== null) {\n          tok += data;\n\n          if ((this._matches(this.tags.BLOCK_START) ||\n            this._matches(this.tags.VARIABLE_START) ||\n            this._matches(this.tags.COMMENT_START)) &&\n            !inComment) {\n            if (this.lstripBlocks &&\n              this._matches(this.tags.BLOCK_START) &&\n              this.colno > 0 &&\n              this.colno <= tok.length) {\n              let lastLine = tok.slice(-this.colno);\n              if (/^\\s+$/.test(lastLine)) {\n                // Remove block leading whitespace from beginning of the string\n                tok = tok.slice(0, -this.colno);\n                if (!tok.length) {\n                  // All data removed, collapse to avoid unnecessary nodes\n                  // by returning next token (block start)\n                  return this.nextToken();\n                }\n              }\n            }\n            // If it is a start tag, stop looping\n            break;\n          } else if (this._matches(this.tags.COMMENT_END)) {\n            if (!inComment) {\n              throw new Error('unexpected end of comment');\n            }\n            tok += this._extractString(this.tags.COMMENT_END);\n            break;\n          } else {\n            // It does not match any tag, so add the character and\n            // carry on\n            tok += this.current();\n            this.forward();\n          }\n        }\n\n        if (data === null && inComment) {\n          throw new Error('expected end of comment, got end of file');\n        }\n\n        return token(inComment ? TOKEN_COMMENT : TOKEN_DATA,\n          tok,\n          lineno,\n          colno);\n      }\n    }\n  }\n\n  _parseString(delimiter) {\n    this.forward();\n\n    let str = '';\n\n    while (!this.isFinished() && this.current() !== delimiter) {\n      let cur = this.current();\n\n      if (cur === '\\\\') {\n        this.forward();\n        switch (this.current()) {\n          case 'n':\n            str += '\\n';\n            break;\n          case 't':\n            str += '\\t';\n            break;\n          case 'r':\n            str += '\\r';\n            break;\n          default:\n            str += this.current();\n        }\n        this.forward();\n      } else {\n        str += cur;\n        this.forward();\n      }\n    }\n\n    this.forward();\n    return str;\n  }\n\n  _matches(str) {\n    if (this.index + str.length > this.len) {\n      return null;\n    }\n\n    let m = this.str.slice(this.index, this.index + str.length);\n    return m === str;\n  }\n\n  _extractString(str) {\n    if (this._matches(str)) {\n      this.forwardN(str.length);\n      return str;\n    }\n    return null;\n  }\n\n  _extractUntil(charString) {\n    // Extract all non-matching chars, with the default matching set\n    // to everything\n    return this._extractMatching(true, charString || '');\n  }\n\n  _extract(charString) {\n    // Extract all matching chars (no default, so charString must be\n    // explicit)\n    return this._extractMatching(false, charString);\n  }\n\n  _extractMatching(breakOnMatch, charString) {\n    // Pull out characters until a breaking char is hit.\n    // If breakOnMatch is false, a non-matching char stops it.\n    // If breakOnMatch is true, a matching char stops it.\n\n    if (this.isFinished()) {\n      return null;\n    }\n\n    let first = charString.indexOf(this.current());\n\n    // Only proceed if the first character doesn't meet our condition\n    if ((breakOnMatch && first === -1) ||\n      (!breakOnMatch && first !== -1)) {\n      let t = this.current();\n      this.forward();\n\n      // And pull out all the chars one at a time until we hit a\n      // breaking char\n      let idx = charString.indexOf(this.current());\n\n      while (((breakOnMatch && idx === -1) ||\n        (!breakOnMatch && idx !== -1)) && !this.isFinished()) {\n        t += this.current();\n        this.forward();\n\n        idx = charString.indexOf(this.current());\n      }\n\n      return t;\n    }\n\n    return '';\n  }\n\n  _extractRegex(regex) {\n    let matches = this.currentStr().match(regex);\n    if (!matches) {\n      return null;\n    }\n\n    // Move forward whatever was matched\n    this.forwardN(matches[0].length);\n\n    return matches;\n  }\n\n  isFinished() {\n    return this.index >= this.len;\n  }\n\n  forwardN(n) {\n    for (let i = 0; i < n; i++) {\n      this.forward();\n    }\n  }\n\n  forward() {\n    this.index++;\n\n    if (this.previous() === '\\n') {\n      this.lineno++;\n      this.colno = 0;\n    } else {\n      this.colno++;\n    }\n  }\n\n  backN(n) {\n    for (let i = 0; i < n; i++) {\n      this.back();\n    }\n  }\n\n  back() {\n    this.index--;\n\n    if (this.current() === '\\n') {\n      this.lineno--;\n\n      let idx = this.src.lastIndexOf('\\n', this.index - 1);\n      if (idx === -1) {\n        this.colno = this.index;\n      } else {\n        this.colno = this.index - idx;\n      }\n    } else {\n      this.colno--;\n    }\n  }\n\n  // current returns current character\n  current() {\n    if (!this.isFinished()) {\n      return this.str.charAt(this.index);\n    }\n    return '';\n  }\n\n  // currentStr returns what's left of the unparsed string\n  currentStr() {\n    if (!this.isFinished()) {\n      return this.str.substr(this.index);\n    }\n    return '';\n  }\n\n  previous() {\n    return this.str.charAt(this.index - 1);\n  }\n}\n\nmodule.exports = {\n  lex(src, opts) {\n    return new Tokenizer(src, opts);\n  },\n\n  TOKEN_STRING: TOKEN_STRING,\n  TOKEN_WHITESPACE: TOKEN_WHITESPACE,\n  TOKEN_DATA: TOKEN_DATA,\n  TOKEN_BLOCK_START: TOKEN_BLOCK_START,\n  TOKEN_BLOCK_END: TOKEN_BLOCK_END,\n  TOKEN_VARIABLE_START: TOKEN_VARIABLE_START,\n  TOKEN_VARIABLE_END: TOKEN_VARIABLE_END,\n  TOKEN_COMMENT: TOKEN_COMMENT,\n  TOKEN_LEFT_PAREN: TOKEN_LEFT_PAREN,\n  TOKEN_RIGHT_PAREN: TOKEN_RIGHT_PAREN,\n  TOKEN_LEFT_BRACKET: TOKEN_LEFT_BRACKET,\n  TOKEN_RIGHT_BRACKET: TOKEN_RIGHT_BRACKET,\n  TOKEN_LEFT_CURLY: TOKEN_LEFT_CURLY,\n  TOKEN_RIGHT_CURLY: TOKEN_RIGHT_CURLY,\n  TOKEN_OPERATOR: TOKEN_OPERATOR,\n  TOKEN_COMMA: TOKEN_COMMA,\n  TOKEN_COLON: TOKEN_COLON,\n  TOKEN_TILDE: TOKEN_TILDE,\n  TOKEN_PIPE: TOKEN_PIPE,\n  TOKEN_INT: TOKEN_INT,\n  TOKEN_FLOAT: TOKEN_FLOAT,\n  TOKEN_BOOLEAN: TOKEN_BOOLEAN,\n  TOKEN_NONE: TOKEN_NONE,\n  TOKEN_SYMBOL: TOKEN_SYMBOL,\n  TOKEN_SPECIAL: TOKEN_SPECIAL,\n  TOKEN_REGEX: TOKEN_REGEX\n};\n\n\n\n// WEBPACK FOOTER //\n// ./nunjucks/src/lexer.js","'use strict';\n\nconst Loader = require('./loader');\nconst {PrecompiledLoader} = require('./precompiled-loader.js');\n\nclass WebLoader extends Loader {\n  constructor(baseURL, opts) {\n    super();\n    this.baseURL = baseURL || '.';\n    opts = opts || {};\n\n    // By default, the cache is turned off because there's no way\n    // to \"watch\" templates over HTTP, so they are re-downloaded\n    // and compiled each time. (Remember, PRECOMPILE YOUR\n    // TEMPLATES in production!)\n    this.useCache = !!opts.useCache;\n\n    // We default `async` to false so that the simple synchronous\n    // API can be used when you aren't doing anything async in\n    // your templates (which is most of the time). This performs a\n    // sync ajax request, but that's ok because it should *only*\n    // happen in development. PRECOMPILE YOUR TEMPLATES.\n    this.async = !!opts.async;\n  }\n\n  resolve(from, to) {\n    throw new Error('relative templates not support in the browser yet');\n  }\n\n  getSource(name, cb) {\n    var useCache = this.useCache;\n    var result;\n    this.fetch(this.baseURL + '/' + name, (err, src) => {\n      if (err) {\n        if (cb) {\n          cb(err.content);\n        } else if (err.status === 404) {\n          result = null;\n        } else {\n          throw err.content;\n        }\n      } else {\n        result = {\n          src: src,\n          path: name,\n          noCache: !useCache\n        };\n        this.emit('load', name, result);\n        if (cb) {\n          cb(null, result);\n        }\n      }\n    });\n\n    // if this WebLoader isn't running asynchronously, the\n    // fetch above would actually run sync and we'll have a\n    // result here\n    return result;\n  }\n\n  fetch(url, cb) {\n    // Only in the browser please\n    if (typeof window === 'undefined') {\n      throw new Error('WebLoader can only by used in a browser');\n    }\n\n    const ajax = new XMLHttpRequest();\n    let loading = true;\n\n    ajax.onreadystatechange = () => {\n      if (ajax.readyState === 4 && loading) {\n        loading = false;\n        if (ajax.status === 0 || ajax.status === 200) {\n          cb(null, ajax.responseText);\n        } else {\n          cb({\n            status: ajax.status,\n            content: ajax.responseText\n          });\n        }\n      }\n    };\n\n    url += (url.indexOf('?') === -1 ? '?' : '&') + 's=' +\n    (new Date().getTime());\n\n    ajax.open('GET', url, this.async);\n    ajax.send();\n  }\n}\n\nmodule.exports = {\n  WebLoader: WebLoader,\n  PrecompiledLoader: PrecompiledLoader\n};\n\n\n\n// WEBPACK FOOTER //\n// ./nunjucks/src/web-loaders.js","'use strict';\n\nconst lib = require('./src/lib');\nconst {Environment, Template} = require('./src/environment');\nconst Loader = require('./src/loader');\nconst loaders = require('./src/loaders');\nconst precompile = require('./src/precompile');\nconst compiler = require('./src/compiler');\nconst parser = require('./src/parser');\nconst lexer = require('./src/lexer');\nconst runtime = require('./src/runtime');\nconst nodes = require('./src/nodes');\nconst installJinjaCompat = require('./src/jinja-compat');\n\n// A single instance of an environment, since this is so commonly used\nlet e;\n\nfunction configure(templatesPath, opts) {\n  opts = opts || {};\n  if (lib.isObject(templatesPath)) {\n    opts = templatesPath;\n    templatesPath = null;\n  }\n\n  let TemplateLoader;\n  if (loaders.FileSystemLoader) {\n    TemplateLoader = new loaders.FileSystemLoader(templatesPath, {\n      watch: opts.watch,\n      noCache: opts.noCache\n    });\n  } else if (loaders.WebLoader) {\n    TemplateLoader = new loaders.WebLoader(templatesPath, {\n      useCache: opts.web && opts.web.useCache,\n      async: opts.web && opts.web.async\n    });\n  }\n\n  e = new Environment(TemplateLoader, opts);\n\n  if (opts && opts.express) {\n    e.express(opts.express);\n  }\n\n  return e;\n}\n\nmodule.exports = {\n  Environment: Environment,\n  Template: Template,\n  Loader: Loader,\n  FileSystemLoader: loaders.FileSystemLoader,\n  NodeResolveLoader: loaders.NodeResolveLoader,\n  PrecompiledLoader: loaders.PrecompiledLoader,\n  WebLoader: loaders.WebLoader,\n  compiler: compiler,\n  parser: parser,\n  lexer: lexer,\n  runtime: runtime,\n  lib: lib,\n  nodes: nodes,\n  installJinjaCompat: installJinjaCompat,\n  configure: configure,\n  reset() {\n    e = undefined;\n  },\n  compile(src, env, path, eagerCompile) {\n    if (!e) {\n      configure();\n    }\n    return new Template(src, env, path, eagerCompile);\n  },\n  render(name, ctx, cb) {\n    if (!e) {\n      configure();\n    }\n\n    return e.render(name, ctx, cb);\n  },\n  renderString(src, ctx, cb) {\n    if (!e) {\n      configure();\n    }\n\n    return e.renderString(src, ctx, cb);\n  },\n  precompile: (precompile) ? precompile.precompile : undefined,\n  precompileString: (precompile) ? precompile.precompileString : undefined,\n};\n\n\n\n// WEBPACK FOOTER //\n// ./nunjucks/index.js","\"use strict\";\n\n// rawAsap provides everything we need except exception management.\nvar rawAsap = require(\"./raw\");\n// RawTasks are recycled to reduce GC churn.\nvar freeTasks = [];\n// We queue errors to ensure they are thrown in right order (FIFO).\n// Array-as-queue is good enough here, since we are just dealing with exceptions.\nvar pendingErrors = [];\nvar requestErrorThrow = rawAsap.makeRequestCallFromTimer(throwFirstError);\n\nfunction throwFirstError() {\n    if (pendingErrors.length) {\n        throw pendingErrors.shift();\n    }\n}\n\n/**\n * Calls a task as soon as possible after returning, in its own event, with priority\n * over other events like animation, reflow, and repaint. An error thrown from an\n * event will not interrupt, nor even substantially slow down the processing of\n * other events, but will be rather postponed to a lower priority event.\n * @param {{call}} task A callable object, typically a function that takes no\n * arguments.\n */\nmodule.exports = asap;\nfunction asap(task) {\n    var rawTask;\n    if (freeTasks.length) {\n        rawTask = freeTasks.pop();\n    } else {\n        rawTask = new RawTask();\n    }\n    rawTask.task = task;\n    rawAsap(rawTask);\n}\n\n// We wrap tasks with recyclable task objects.  A task object implements\n// `call`, just like a function.\nfunction RawTask() {\n    this.task = null;\n}\n\n// The sole purpose of wrapping the task is to catch the exception and recycle\n// the task object after its single use.\nRawTask.prototype.call = function () {\n    try {\n        this.task.call();\n    } catch (error) {\n        if (asap.onerror) {\n            // This hook exists purely for testing purposes.\n            // Its name will be periodically randomized to break any code that\n            // depends on its existence.\n            asap.onerror(error);\n        } else {\n            // In a web browser, exceptions are not fatal. However, to avoid\n            // slowing down the queue of pending tasks, we rethrow the error in a\n            // lower priority turn.\n            pendingErrors.push(error);\n            requestErrorThrow();\n        }\n    } finally {\n        this.task = null;\n        freeTasks[freeTasks.length] = this;\n    }\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/asap/browser-asap.js\n// module id = 12\n// module chunks = 0","\"use strict\";\n\n// Use the fastest means possible to execute a task in its own turn, with\n// priority over other events including IO, animation, reflow, and redraw\n// events in browsers.\n//\n// An exception thrown by a task will permanently interrupt the processing of\n// subsequent tasks. The higher level `asap` function ensures that if an\n// exception is thrown by a task, that the task queue will continue flushing as\n// soon as possible, but if you use `rawAsap` directly, you are responsible to\n// either ensure that no exceptions are thrown from your task, or to manually\n// call `rawAsap.requestFlush` if an exception is thrown.\nmodule.exports = rawAsap;\nfunction rawAsap(task) {\n    if (!queue.length) {\n        requestFlush();\n        flushing = true;\n    }\n    // Equivalent to push, but avoids a function call.\n    queue[queue.length] = task;\n}\n\nvar queue = [];\n// Once a flush has been requested, no further calls to `requestFlush` are\n// necessary until the next `flush` completes.\nvar flushing = false;\n// `requestFlush` is an implementation-specific method that attempts to kick\n// off a `flush` event as quickly as possible. `flush` will attempt to exhaust\n// the event queue before yielding to the browser's own event loop.\nvar requestFlush;\n// The position of the next task to execute in the task queue. This is\n// preserved between calls to `flush` so that it can be resumed if\n// a task throws an exception.\nvar index = 0;\n// If a task schedules additional tasks recursively, the task queue can grow\n// unbounded. To prevent memory exhaustion, the task queue will periodically\n// truncate already-completed tasks.\nvar capacity = 1024;\n\n// The flush function processes all tasks that have been scheduled with\n// `rawAsap` unless and until one of those tasks throws an exception.\n// If a task throws an exception, `flush` ensures that its state will remain\n// consistent and will resume where it left off when called again.\n// However, `flush` does not make any arrangements to be called again if an\n// exception is thrown.\nfunction flush() {\n    while (index < queue.length) {\n        var currentIndex = index;\n        // Advance the index before calling the task. This ensures that we will\n        // begin flushing on the next task the task throws an error.\n        index = index + 1;\n        queue[currentIndex].call();\n        // Prevent leaking memory for long chains of recursive calls to `asap`.\n        // If we call `asap` within tasks scheduled by `asap`, the queue will\n        // grow, but to avoid an O(n) walk for every task we execute, we don't\n        // shift tasks off the queue after they have been executed.\n        // Instead, we periodically shift 1024 tasks off the queue.\n        if (index > capacity) {\n            // Manually shift all values starting at the index back to the\n            // beginning of the queue.\n            for (var scan = 0, newLength = queue.length - index; scan < newLength; scan++) {\n                queue[scan] = queue[scan + index];\n            }\n            queue.length -= index;\n            index = 0;\n        }\n    }\n    queue.length = 0;\n    index = 0;\n    flushing = false;\n}\n\n// `requestFlush` is implemented using a strategy based on data collected from\n// every available SauceLabs Selenium web driver worker at time of writing.\n// https://docs.google.com/spreadsheets/d/1mG-5UYGup5qxGdEMWkhP6BWCz053NUb2E1QoUTU16uA/edit#gid=783724593\n\n// Safari 6 and 6.1 for desktop, iPad, and iPhone are the only browsers that\n// have WebKitMutationObserver but not un-prefixed MutationObserver.\n// Must use `global` or `self` instead of `window` to work in both frames and web\n// workers. `global` is a provision of Browserify, Mr, Mrs, or Mop.\n\n/* globals self */\nvar scope = typeof global !== \"undefined\" ? global : self;\nvar BrowserMutationObserver = scope.MutationObserver || scope.WebKitMutationObserver;\n\n// MutationObservers are desirable because they have high priority and work\n// reliably everywhere they are implemented.\n// They are implemented in all modern browsers.\n//\n// - Android 4-4.3\n// - Chrome 26-34\n// - Firefox 14-29\n// - Internet Explorer 11\n// - iPad Safari 6-7.1\n// - iPhone Safari 7-7.1\n// - Safari 6-7\nif (typeof BrowserMutationObserver === \"function\") {\n    requestFlush = makeRequestCallFromMutationObserver(flush);\n\n// MessageChannels are desirable because they give direct access to the HTML\n// task queue, are implemented in Internet Explorer 10, Safari 5.0-1, and Opera\n// 11-12, and in web workers in many engines.\n// Although message channels yield to any queued rendering and IO tasks, they\n// would be better than imposing the 4ms delay of timers.\n// However, they do not work reliably in Internet Explorer or Safari.\n\n// Internet Explorer 10 is the only browser that has setImmediate but does\n// not have MutationObservers.\n// Although setImmediate yields to the browser's renderer, it would be\n// preferrable to falling back to setTimeout since it does not have\n// the minimum 4ms penalty.\n// Unfortunately there appears to be a bug in Internet Explorer 10 Mobile (and\n// Desktop to a lesser extent) that renders both setImmediate and\n// MessageChannel useless for the purposes of ASAP.\n// https://github.com/kriskowal/q/issues/396\n\n// Timers are implemented universally.\n// We fall back to timers in workers in most engines, and in foreground\n// contexts in the following browsers.\n// However, note that even this simple case requires nuances to operate in a\n// broad spectrum of browsers.\n//\n// - Firefox 3-13\n// - Internet Explorer 6-9\n// - iPad Safari 4.3\n// - Lynx 2.8.7\n} else {\n    requestFlush = makeRequestCallFromTimer(flush);\n}\n\n// `requestFlush` requests that the high priority event queue be flushed as\n// soon as possible.\n// This is useful to prevent an error thrown in a task from stalling the event\n// queue if the exception handled by Node.js’s\n// `process.on(\"uncaughtException\")` or by a domain.\nrawAsap.requestFlush = requestFlush;\n\n// To request a high priority event, we induce a mutation observer by toggling\n// the text of a text node between \"1\" and \"-1\".\nfunction makeRequestCallFromMutationObserver(callback) {\n    var toggle = 1;\n    var observer = new BrowserMutationObserver(callback);\n    var node = document.createTextNode(\"\");\n    observer.observe(node, {characterData: true});\n    return function requestCall() {\n        toggle = -toggle;\n        node.data = toggle;\n    };\n}\n\n// The message channel technique was discovered by Malte Ubl and was the\n// original foundation for this library.\n// http://www.nonblocking.io/2011/06/windownexttick.html\n\n// Safari 6.0.5 (at least) intermittently fails to create message ports on a\n// page's first load. Thankfully, this version of Safari supports\n// MutationObservers, so we don't need to fall back in that case.\n\n// function makeRequestCallFromMessageChannel(callback) {\n//     var channel = new MessageChannel();\n//     channel.port1.onmessage = callback;\n//     return function requestCall() {\n//         channel.port2.postMessage(0);\n//     };\n// }\n\n// For reasons explained above, we are also unable to use `setImmediate`\n// under any circumstances.\n// Even if we were, there is another bug in Internet Explorer 10.\n// It is not sufficient to assign `setImmediate` to `requestFlush` because\n// `setImmediate` must be called *by name* and therefore must be wrapped in a\n// closure.\n// Never forget.\n\n// function makeRequestCallFromSetImmediate(callback) {\n//     return function requestCall() {\n//         setImmediate(callback);\n//     };\n// }\n\n// Safari 6.0 has a problem where timers will get lost while the user is\n// scrolling. This problem does not impact ASAP because Safari 6.0 supports\n// mutation observers, so that implementation is used instead.\n// However, if we ever elect to use timers in Safari, the prevalent work-around\n// is to add a scroll event listener that calls for a flush.\n\n// `setTimeout` does not call the passed callback if the delay is less than\n// approximately 7 in web workers in Firefox 8 through 18, and sometimes not\n// even then.\n\nfunction makeRequestCallFromTimer(callback) {\n    return function requestCall() {\n        // We dispatch a timeout with a specified delay of 0 for engines that\n        // can reliably accommodate that request. This will usually be snapped\n        // to a 4 milisecond delay, but once we're flushing, there's no delay\n        // between events.\n        var timeoutHandle = setTimeout(handleTimer, 0);\n        // However, since this timer gets frequently dropped in Firefox\n        // workers, we enlist an interval handle that will try to fire\n        // an event 20 times per second until it succeeds.\n        var intervalHandle = setInterval(handleTimer, 50);\n\n        function handleTimer() {\n            // Whichever timer succeeds will cancel both timers and\n            // execute the callback.\n            clearTimeout(timeoutHandle);\n            clearInterval(intervalHandle);\n            callback();\n        }\n    };\n}\n\n// This is for `asap.js` only.\n// Its name will be periodically randomized to break any code that depends on\n// its existence.\nrawAsap.makeRequestCallFromTimer = makeRequestCallFromTimer;\n\n// ASAP was originally a nextTick shim included in Q. This was factored out\n// into this ASAP package. It was later adapted to RSVP which made further\n// amendments. These decisions, particularly to marginalize MessageChannel and\n// to capture the MutationObserver implementation in a closure, were integrated\n// back into ASAP proper.\n// https://github.com/tildeio/rsvp.js/blob/cddf7232546a9cf858524b75cde6f9edf72620a7/lib/rsvp/asap.js\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/asap/browser-raw.js\n// module id = 13\n// module chunks = 0","var g;\r\n\r\n// This works in non-strict mode\r\ng = (function() {\r\n\treturn this;\r\n})();\r\n\r\ntry {\r\n\t// This works if eval is allowed (see CSP)\r\n\tg = g || Function(\"return this\")() || (1,eval)(\"this\");\r\n} catch(e) {\r\n\t// This works if the window reference is available\r\n\tif(typeof window === \"object\")\r\n\t\tg = window;\r\n}\r\n\r\n// g can still be undefined, but nothing to do about it...\r\n// We return undefined, instead of nothing here, so it's\r\n// easier to handle this case. if(!global) { ...}\r\n\r\nmodule.exports = g;\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// (webpack)/buildin/global.js\n// module id = 14\n// module chunks = 0","// MIT license (by Elan Shanker).\n(function(globals) {\n  'use strict';\n\n  var executeSync = function(){\n    var args = Array.prototype.slice.call(arguments);\n    if (typeof args[0] === 'function'){\n      args[0].apply(null, args.splice(1));\n    }\n  };\n\n  var executeAsync = function(fn){\n    if (typeof setImmediate === 'function') {\n      setImmediate(fn);\n    } else if (typeof process !== 'undefined' && process.nextTick) {\n      process.nextTick(fn);\n    } else {\n      setTimeout(fn, 0);\n    }\n  };\n\n  var makeIterator = function (tasks) {\n    var makeCallback = function (index) {\n      var fn = function () {\n        if (tasks.length) {\n          tasks[index].apply(null, arguments);\n        }\n        return fn.next();\n      };\n      fn.next = function () {\n        return (index < tasks.length - 1) ? makeCallback(index + 1): null;\n      };\n      return fn;\n    };\n    return makeCallback(0);\n  };\n  \n  var _isArray = Array.isArray || function(maybeArray){\n    return Object.prototype.toString.call(maybeArray) === '[object Array]';\n  };\n\n  var waterfall = function (tasks, callback, forceAsync) {\n    var nextTick = forceAsync ? executeAsync : executeSync;\n    callback = callback || function () {};\n    if (!_isArray(tasks)) {\n      var err = new Error('First argument to waterfall must be an array of functions');\n      return callback(err);\n    }\n    if (!tasks.length) {\n      return callback();\n    }\n    var wrapIterator = function (iterator) {\n      return function (err) {\n        if (err) {\n          callback.apply(null, arguments);\n          callback = function () {};\n        } else {\n          var args = Array.prototype.slice.call(arguments, 1);\n          var next = iterator.next();\n          if (next) {\n            args.push(wrapIterator(next));\n          } else {\n            args.push(callback);\n          }\n          nextTick(function () {\n            iterator.apply(null, args);\n          });\n        }\n      };\n    };\n    wrapIterator(makeIterator(tasks))();\n  };\n\n  if (typeof define !== 'undefined' && define.amd) {\n    define([], function () {\n      return waterfall;\n    }); // RequireJS\n  } else if (typeof module !== 'undefined' && module.exports) {\n    module.exports = waterfall; // CommonJS\n  } else {\n    globals.waterfall = waterfall; // <script>\n  }\n})(this);\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/a-sync-waterfall/index.js\n// module id = 15\n// module chunks = 0","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar R = typeof Reflect === 'object' ? Reflect : null\nvar ReflectApply = R && typeof R.apply === 'function'\n  ? R.apply\n  : function ReflectApply(target, receiver, args) {\n    return Function.prototype.apply.call(target, receiver, args);\n  }\n\nvar ReflectOwnKeys\nif (R && typeof R.ownKeys === 'function') {\n  ReflectOwnKeys = R.ownKeys\n} else if (Object.getOwnPropertySymbols) {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target)\n      .concat(Object.getOwnPropertySymbols(target));\n  };\n} else {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target);\n  };\n}\n\nfunction ProcessEmitWarning(warning) {\n  if (console && console.warn) console.warn(warning);\n}\n\nvar NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {\n  return value !== value;\n}\n\nfunction EventEmitter() {\n  EventEmitter.init.call(this);\n}\nmodule.exports = EventEmitter;\nmodule.exports.once = once;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._eventsCount = 0;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nvar defaultMaxListeners = 10;\n\nfunction checkListener(listener) {\n  if (typeof listener !== 'function') {\n    throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n  }\n}\n\nObject.defineProperty(EventEmitter, 'defaultMaxListeners', {\n  enumerable: true,\n  get: function() {\n    return defaultMaxListeners;\n  },\n  set: function(arg) {\n    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {\n      throw new RangeError('The value of \"defaultMaxListeners\" is out of range. It must be a non-negative number. Received ' + arg + '.');\n    }\n    defaultMaxListeners = arg;\n  }\n});\n\nEventEmitter.init = function() {\n\n  if (this._events === undefined ||\n      this._events === Object.getPrototypeOf(this)._events) {\n    this._events = Object.create(null);\n    this._eventsCount = 0;\n  }\n\n  this._maxListeners = this._maxListeners || undefined;\n};\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {\n    throw new RangeError('The value of \"n\" is out of range. It must be a non-negative number. Received ' + n + '.');\n  }\n  this._maxListeners = n;\n  return this;\n};\n\nfunction _getMaxListeners(that) {\n  if (that._maxListeners === undefined)\n    return EventEmitter.defaultMaxListeners;\n  return that._maxListeners;\n}\n\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n  return _getMaxListeners(this);\n};\n\nEventEmitter.prototype.emit = function emit(type) {\n  var args = [];\n  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);\n  var doError = (type === 'error');\n\n  var events = this._events;\n  if (events !== undefined)\n    doError = (doError && events.error === undefined);\n  else if (!doError)\n    return false;\n\n  // If there is no 'error' event listener then throw.\n  if (doError) {\n    var er;\n    if (args.length > 0)\n      er = args[0];\n    if (er instanceof Error) {\n      // Note: The comments on the `throw` lines are intentional, they show\n      // up in Node's output if this results in an unhandled exception.\n      throw er; // Unhandled 'error' event\n    }\n    // At least give some kind of context to the user\n    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));\n    err.context = er;\n    throw err; // Unhandled 'error' event\n  }\n\n  var handler = events[type];\n\n  if (handler === undefined)\n    return false;\n\n  if (typeof handler === 'function') {\n    ReflectApply(handler, this, args);\n  } else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      ReflectApply(listeners[i], this, args);\n  }\n\n  return true;\n};\n\nfunction _addListener(target, type, listener, prepend) {\n  var m;\n  var events;\n  var existing;\n\n  checkListener(listener);\n\n  events = target._events;\n  if (events === undefined) {\n    events = target._events = Object.create(null);\n    target._eventsCount = 0;\n  } else {\n    // To avoid recursion in the case that type === \"newListener\"! Before\n    // adding it to the listeners, first emit \"newListener\".\n    if (events.newListener !== undefined) {\n      target.emit('newListener', type,\n                  listener.listener ? listener.listener : listener);\n\n      // Re-assign `events` because a newListener handler could have caused the\n      // this._events to be assigned to a new object\n      events = target._events;\n    }\n    existing = events[type];\n  }\n\n  if (existing === undefined) {\n    // Optimize the case of one listener. Don't need the extra array object.\n    existing = events[type] = listener;\n    ++target._eventsCount;\n  } else {\n    if (typeof existing === 'function') {\n      // Adding the second element, need to change to array.\n      existing = events[type] =\n        prepend ? [listener, existing] : [existing, listener];\n      // If we've already got an array, just append.\n    } else if (prepend) {\n      existing.unshift(listener);\n    } else {\n      existing.push(listener);\n    }\n\n    // Check for listener leak\n    m = _getMaxListeners(target);\n    if (m > 0 && existing.length > m && !existing.warned) {\n      existing.warned = true;\n      // No error code for this since it is a Warning\n      // eslint-disable-next-line no-restricted-syntax\n      var w = new Error('Possible EventEmitter memory leak detected. ' +\n                          existing.length + ' ' + String(type) + ' listeners ' +\n                          'added. Use emitter.setMaxListeners() to ' +\n                          'increase limit');\n      w.name = 'MaxListenersExceededWarning';\n      w.emitter = target;\n      w.type = type;\n      w.count = existing.length;\n      ProcessEmitWarning(w);\n    }\n  }\n\n  return target;\n}\n\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n  return _addListener(this, type, listener, false);\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.prependListener =\n    function prependListener(type, listener) {\n      return _addListener(this, type, listener, true);\n    };\n\nfunction onceWrapper() {\n  if (!this.fired) {\n    this.target.removeListener(this.type, this.wrapFn);\n    this.fired = true;\n    if (arguments.length === 0)\n      return this.listener.call(this.target);\n    return this.listener.apply(this.target, arguments);\n  }\n}\n\nfunction _onceWrap(target, type, listener) {\n  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };\n  var wrapped = onceWrapper.bind(state);\n  wrapped.listener = listener;\n  state.wrapFn = wrapped;\n  return wrapped;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n  checkListener(listener);\n  this.on(type, _onceWrap(this, type, listener));\n  return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n    function prependOnceListener(type, listener) {\n      checkListener(listener);\n      this.prependListener(type, _onceWrap(this, type, listener));\n      return this;\n    };\n\n// Emits a 'removeListener' event if and only if the listener was removed.\nEventEmitter.prototype.removeListener =\n    function removeListener(type, listener) {\n      var list, events, position, i, originalListener;\n\n      checkListener(listener);\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      list = events[type];\n      if (list === undefined)\n        return this;\n\n      if (list === listener || list.listener === listener) {\n        if (--this._eventsCount === 0)\n          this._events = Object.create(null);\n        else {\n          delete events[type];\n          if (events.removeListener)\n            this.emit('removeListener', type, list.listener || listener);\n        }\n      } else if (typeof list !== 'function') {\n        position = -1;\n\n        for (i = list.length - 1; i >= 0; i--) {\n          if (list[i] === listener || list[i].listener === listener) {\n            originalListener = list[i].listener;\n            position = i;\n            break;\n          }\n        }\n\n        if (position < 0)\n          return this;\n\n        if (position === 0)\n          list.shift();\n        else {\n          spliceOne(list, position);\n        }\n\n        if (list.length === 1)\n          events[type] = list[0];\n\n        if (events.removeListener !== undefined)\n          this.emit('removeListener', type, originalListener || listener);\n      }\n\n      return this;\n    };\n\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\n\nEventEmitter.prototype.removeAllListeners =\n    function removeAllListeners(type) {\n      var listeners, events, i;\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      // not listening for removeListener, no need to emit\n      if (events.removeListener === undefined) {\n        if (arguments.length === 0) {\n          this._events = Object.create(null);\n          this._eventsCount = 0;\n        } else if (events[type] !== undefined) {\n          if (--this._eventsCount === 0)\n            this._events = Object.create(null);\n          else\n            delete events[type];\n        }\n        return this;\n      }\n\n      // emit removeListener for all listeners on all events\n      if (arguments.length === 0) {\n        var keys = Object.keys(events);\n        var key;\n        for (i = 0; i < keys.length; ++i) {\n          key = keys[i];\n          if (key === 'removeListener') continue;\n          this.removeAllListeners(key);\n        }\n        this.removeAllListeners('removeListener');\n        this._events = Object.create(null);\n        this._eventsCount = 0;\n        return this;\n      }\n\n      listeners = events[type];\n\n      if (typeof listeners === 'function') {\n        this.removeListener(type, listeners);\n      } else if (listeners !== undefined) {\n        // LIFO order\n        for (i = listeners.length - 1; i >= 0; i--) {\n          this.removeListener(type, listeners[i]);\n        }\n      }\n\n      return this;\n    };\n\nfunction _listeners(target, type, unwrap) {\n  var events = target._events;\n\n  if (events === undefined)\n    return [];\n\n  var evlistener = events[type];\n  if (evlistener === undefined)\n    return [];\n\n  if (typeof evlistener === 'function')\n    return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n\n  return unwrap ?\n    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n}\n\nEventEmitter.prototype.listeners = function listeners(type) {\n  return _listeners(this, type, true);\n};\n\nEventEmitter.prototype.rawListeners = function rawListeners(type) {\n  return _listeners(this, type, false);\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  if (typeof emitter.listenerCount === 'function') {\n    return emitter.listenerCount(type);\n  } else {\n    return listenerCount.call(emitter, type);\n  }\n};\n\nEventEmitter.prototype.listenerCount = listenerCount;\nfunction listenerCount(type) {\n  var events = this._events;\n\n  if (events !== undefined) {\n    var evlistener = events[type];\n\n    if (typeof evlistener === 'function') {\n      return 1;\n    } else if (evlistener !== undefined) {\n      return evlistener.length;\n    }\n  }\n\n  return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];\n};\n\nfunction arrayClone(arr, n) {\n  var copy = new Array(n);\n  for (var i = 0; i < n; ++i)\n    copy[i] = arr[i];\n  return copy;\n}\n\nfunction spliceOne(list, index) {\n  for (; index + 1 < list.length; index++)\n    list[index] = list[index + 1];\n  list.pop();\n}\n\nfunction unwrapListeners(arr) {\n  var ret = new Array(arr.length);\n  for (var i = 0; i < ret.length; ++i) {\n    ret[i] = arr[i].listener || arr[i];\n  }\n  return ret;\n}\n\nfunction once(emitter, name) {\n  return new Promise(function (resolve, reject) {\n    function eventListener() {\n      if (errorListener !== undefined) {\n        emitter.removeListener('error', errorListener);\n      }\n      resolve([].slice.call(arguments));\n    };\n    var errorListener;\n\n    // Adding an error listener is not optional because\n    // if an error is thrown on an event emitter we cannot\n    // guarantee that the actual event we are waiting will\n    // be fired. The result could be a silent way to create\n    // memory or file descriptor leaks, which is something\n    // we should avoid.\n    if (name !== 'error') {\n      errorListener = function errorListener(err) {\n        emitter.removeListener(name, eventListener);\n        reject(err);\n      };\n\n      emitter.once('error', errorListener);\n    }\n\n    emitter.once(name, eventListener);\n  });\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// (webpack)/node_modules/events/events.js\n// module id = 16\n// module chunks = 0","'use strict';\n\nvar nodes = require('./nodes');\nvar lib = require('./lib');\n\nvar sym = 0;\nfunction gensym() {\n  return 'hole_' + sym++;\n}\n\n// copy-on-write version of map\nfunction mapCOW(arr, func) {\n  var res = null;\n  for (let i = 0; i < arr.length; i++) {\n    const item = func(arr[i]);\n\n    if (item !== arr[i]) {\n      if (!res) {\n        res = arr.slice();\n      }\n\n      res[i] = item;\n    }\n  }\n\n  return res || arr;\n}\n\nfunction walk(ast, func, depthFirst) {\n  if (!(ast instanceof nodes.Node)) {\n    return ast;\n  }\n\n  if (!depthFirst) {\n    const astT = func(ast);\n\n    if (astT && astT !== ast) {\n      return astT;\n    }\n  }\n\n  if (ast instanceof nodes.NodeList) {\n    const children = mapCOW(ast.children, (node) => walk(node, func, depthFirst));\n\n    if (children !== ast.children) {\n      ast = new nodes[ast.typename](ast.lineno, ast.colno, children);\n    }\n  } else if (ast instanceof nodes.CallExtension) {\n    const args = walk(ast.args, func, depthFirst);\n    const contentArgs = mapCOW(ast.contentArgs, (node) => walk(node, func, depthFirst));\n\n    if (args !== ast.args || contentArgs !== ast.contentArgs) {\n      ast = new nodes[ast.typename](ast.extName, ast.prop, args, contentArgs);\n    }\n  } else {\n    const props = ast.fields.map((field) => ast[field]);\n    const propsT = mapCOW(props, (prop) => walk(prop, func, depthFirst));\n\n    if (propsT !== props) {\n      ast = new nodes[ast.typename](ast.lineno, ast.colno);\n      propsT.forEach((prop, i) => {\n        ast[ast.fields[i]] = prop;\n      });\n    }\n  }\n\n  return depthFirst ? (func(ast) || ast) : ast;\n}\n\nfunction depthWalk(ast, func) {\n  return walk(ast, func, true);\n}\n\nfunction _liftFilters(node, asyncFilters, prop) {\n  var children = [];\n\n  var walked = depthWalk(prop ? node[prop] : node, (descNode) => {\n    let symbol;\n    if (descNode instanceof nodes.Block) {\n      return descNode;\n    } else if ((descNode instanceof nodes.Filter &&\n      lib.indexOf(asyncFilters, descNode.name.value) !== -1) ||\n      descNode instanceof nodes.CallExtensionAsync) {\n      symbol = new nodes.Symbol(descNode.lineno,\n        descNode.colno,\n        gensym());\n\n      children.push(new nodes.FilterAsync(descNode.lineno,\n        descNode.colno,\n        descNode.name,\n        descNode.args,\n        symbol));\n    }\n    return symbol;\n  });\n\n  if (prop) {\n    node[prop] = walked;\n  } else {\n    node = walked;\n  }\n\n  if (children.length) {\n    children.push(node);\n\n    return new nodes.NodeList(\n      node.lineno,\n      node.colno,\n      children\n    );\n  } else {\n    return node;\n  }\n}\n\nfunction liftFilters(ast, asyncFilters) {\n  return depthWalk(ast, (node) => {\n    if (node instanceof nodes.Output) {\n      return _liftFilters(node, asyncFilters);\n    } else if (node instanceof nodes.Set) {\n      return _liftFilters(node, asyncFilters, 'value');\n    } else if (node instanceof nodes.For) {\n      return _liftFilters(node, asyncFilters, 'arr');\n    } else if (node instanceof nodes.If) {\n      return _liftFilters(node, asyncFilters, 'cond');\n    } else if (node instanceof nodes.CallExtension) {\n      return _liftFilters(node, asyncFilters, 'args');\n    } else {\n      return undefined;\n    }\n  });\n}\n\nfunction liftSuper(ast) {\n  return walk(ast, (blockNode) => {\n    if (!(blockNode instanceof nodes.Block)) {\n      return;\n    }\n\n    let hasSuper = false;\n    const symbol = gensym();\n\n    blockNode.body = walk(blockNode.body, (node) => { // eslint-disable-line consistent-return\n      if (node instanceof nodes.FunCall && node.name.value === 'super') {\n        hasSuper = true;\n        return new nodes.Symbol(node.lineno, node.colno, symbol);\n      }\n    });\n\n    if (hasSuper) {\n      blockNode.body.children.unshift(new nodes.Super(\n        0, 0, blockNode.name, new nodes.Symbol(0, 0, symbol)\n      ));\n    }\n  });\n}\n\nfunction convertStatements(ast) {\n  return depthWalk(ast, (node) => {\n    if (!(node instanceof nodes.If) && !(node instanceof nodes.For)) {\n      return undefined;\n    }\n\n    let async = false;\n    walk(node, (child) => {\n      if (child instanceof nodes.FilterAsync ||\n        child instanceof nodes.IfAsync ||\n        child instanceof nodes.AsyncEach ||\n        child instanceof nodes.AsyncAll ||\n        child instanceof nodes.CallExtensionAsync) {\n        async = true;\n        // Stop iterating by returning the node\n        return child;\n      }\n      return undefined;\n    });\n\n    if (async) {\n      if (node instanceof nodes.If) {\n        return new nodes.IfAsync(\n          node.lineno,\n          node.colno,\n          node.cond,\n          node.body,\n          node.else_\n        );\n      } else if (node instanceof nodes.For && !(node instanceof nodes.AsyncAll)) {\n        return new nodes.AsyncEach(\n          node.lineno,\n          node.colno,\n          node.arr,\n          node.name,\n          node.body,\n          node.else_\n        );\n      }\n    }\n    return undefined;\n  });\n}\n\nfunction cps(ast, asyncFilters) {\n  return convertStatements(liftSuper(liftFilters(ast, asyncFilters)));\n}\n\nfunction transform(ast, asyncFilters) {\n  return cps(ast, asyncFilters || []);\n}\n\n// var parser = require('./parser');\n// var src = 'hello {% foo %}{% endfoo %} end';\n// var ast = transform(parser.parse(src, [new FooExtension()]), ['bar']);\n// nodes.printNodes(ast);\n\nmodule.exports = {\n  transform: transform\n};\n\n\n\n// WEBPACK FOOTER //\n// ./nunjucks/src/transformer.js","'use strict';\n\nvar lib = require('./lib');\nvar r = require('./runtime');\n\nvar exports = module.exports = {};\n\nfunction normalize(value, defaultValue) {\n  if (value === null || value === undefined || value === false) {\n    return defaultValue;\n  }\n  return value;\n}\n\nexports.abs = Math.abs;\n\nfunction isNaN(num) {\n  return num !== num; // eslint-disable-line no-self-compare\n}\n\nfunction batch(arr, linecount, fillWith) {\n  var i;\n  var res = [];\n  var tmp = [];\n\n  for (i = 0; i < arr.length; i++) {\n    if (i % linecount === 0 && tmp.length) {\n      res.push(tmp);\n      tmp = [];\n    }\n\n    tmp.push(arr[i]);\n  }\n\n  if (tmp.length) {\n    if (fillWith) {\n      for (i = tmp.length; i < linecount; i++) {\n        tmp.push(fillWith);\n      }\n    }\n\n    res.push(tmp);\n  }\n\n  return res;\n}\n\nexports.batch = batch;\n\nfunction capitalize(str) {\n  str = normalize(str, '');\n  const ret = str.toLowerCase();\n  return r.copySafeness(str, ret.charAt(0).toUpperCase() + ret.slice(1));\n}\n\nexports.capitalize = capitalize;\n\nfunction center(str, width) {\n  str = normalize(str, '');\n  width = width || 80;\n\n  if (str.length >= width) {\n    return str;\n  }\n\n  const spaces = width - str.length;\n  const pre = lib.repeat(' ', (spaces / 2) - (spaces % 2));\n  const post = lib.repeat(' ', spaces / 2);\n  return r.copySafeness(str, pre + str + post);\n}\n\nexports.center = center;\n\nfunction default_(val, def, bool) {\n  if (bool) {\n    return val || def;\n  } else {\n    return (val !== undefined) ? val : def;\n  }\n}\n\n// TODO: it is confusing to export something called 'default'\nexports['default'] = default_; // eslint-disable-line dot-notation\n\nfunction dictsort(val, caseSensitive, by) {\n  if (!lib.isObject(val)) {\n    throw new lib.TemplateError('dictsort filter: val must be an object');\n  }\n\n  let array = [];\n  // deliberately include properties from the object's prototype\n  for (let k in val) { // eslint-disable-line guard-for-in, no-restricted-syntax\n    array.push([k, val[k]]);\n  }\n\n  let si;\n  if (by === undefined || by === 'key') {\n    si = 0;\n  } else if (by === 'value') {\n    si = 1;\n  } else {\n    throw new lib.TemplateError(\n      'dictsort filter: You can only sort by either key or value');\n  }\n\n  array.sort((t1, t2) => {\n    var a = t1[si];\n    var b = t2[si];\n\n    if (!caseSensitive) {\n      if (lib.isString(a)) {\n        a = a.toUpperCase();\n      }\n      if (lib.isString(b)) {\n        b = b.toUpperCase();\n      }\n    }\n\n    return a > b ? 1 : (a === b ? 0 : -1); // eslint-disable-line no-nested-ternary\n  });\n\n  return array;\n}\n\nexports.dictsort = dictsort;\n\nfunction dump(obj, spaces) {\n  return JSON.stringify(obj, null, spaces);\n}\n\nexports.dump = dump;\n\nfunction escape(str) {\n  if (str instanceof r.SafeString) {\n    return str;\n  }\n  str = (str === null || str === undefined) ? '' : str;\n  return r.markSafe(lib.escape(str.toString()));\n}\n\nexports.escape = escape;\n\nfunction safe(str) {\n  if (str instanceof r.SafeString) {\n    return str;\n  }\n  str = (str === null || str === undefined) ? '' : str;\n  return r.markSafe(str.toString());\n}\n\nexports.safe = safe;\n\nfunction first(arr) {\n  return arr[0];\n}\n\nexports.first = first;\n\nfunction forceescape(str) {\n  str = (str === null || str === undefined) ? '' : str;\n  return r.markSafe(lib.escape(str.toString()));\n}\n\nexports.forceescape = forceescape;\n\nfunction groupby(arr, attr) {\n  return lib.groupBy(arr, attr, this.env.opts.throwOnUndefined);\n}\n\nexports.groupby = groupby;\n\nfunction indent(str, width, indentfirst) {\n  str = normalize(str, '');\n\n  if (str === '') {\n    return '';\n  }\n\n  width = width || 4;\n  // let res = '';\n  const lines = str.split('\\n');\n  const sp = lib.repeat(' ', width);\n\n  const res = lines.map((l, i) => {\n    return (i === 0 && !indentfirst) ? l : `${sp}${l}`;\n  }).join('\\n');\n\n  return r.copySafeness(str, res);\n}\n\nexports.indent = indent;\n\nfunction join(arr, del, attr) {\n  del = del || '';\n\n  if (attr) {\n    arr = lib.map(arr, (v) => v[attr]);\n  }\n\n  return arr.join(del);\n}\n\nexports.join = join;\n\nfunction last(arr) {\n  return arr[arr.length - 1];\n}\n\nexports.last = last;\n\nfunction lengthFilter(val) {\n  var value = normalize(val, '');\n\n  if (value !== undefined) {\n    if (\n      (typeof Map === 'function' && value instanceof Map) ||\n      (typeof Set === 'function' && value instanceof Set)\n    ) {\n      // ECMAScript 2015 Maps and Sets\n      return value.size;\n    }\n    if (lib.isObject(value) && !(value instanceof r.SafeString)) {\n      // Objects (besides SafeStrings), non-primative Arrays\n      return lib.keys(value).length;\n    }\n    return value.length;\n  }\n  return 0;\n}\n\nexports.length = lengthFilter;\n\nfunction list(val) {\n  if (lib.isString(val)) {\n    return val.split('');\n  } else if (lib.isObject(val)) {\n    return lib._entries(val || {}).map(([key, value]) => ({key, value}));\n  } else if (lib.isArray(val)) {\n    return val;\n  } else {\n    throw new lib.TemplateError('list filter: type not iterable');\n  }\n}\n\nexports.list = list;\n\nfunction lower(str) {\n  str = normalize(str, '');\n  return str.toLowerCase();\n}\n\nexports.lower = lower;\n\nfunction nl2br(str) {\n  if (str === null || str === undefined) {\n    return '';\n  }\n  return r.copySafeness(str, str.replace(/\\r\\n|\\n/g, '<br />\\n'));\n}\n\nexports.nl2br = nl2br;\n\nfunction random(arr) {\n  return arr[Math.floor(Math.random() * arr.length)];\n}\n\nexports.random = random;\n\n/**\n * Construct select or reject filter\n *\n * @param {boolean} expectedTestResult\n * @returns {function(array, string, *): array}\n */\nfunction getSelectOrReject(expectedTestResult) {\n  function filter(arr, testName = 'truthy', secondArg) {\n    const context = this;\n    const test = context.env.getTest(testName);\n\n    return lib.toArray(arr).filter(function examineTestResult(item) {\n      return test.call(context, item, secondArg) === expectedTestResult;\n    });\n  }\n\n  return filter;\n}\n\nexports.reject = getSelectOrReject(false);\n\nfunction rejectattr(arr, attr) {\n  return arr.filter((item) => !item[attr]);\n}\n\nexports.rejectattr = rejectattr;\n\nexports.select = getSelectOrReject(true);\n\nfunction selectattr(arr, attr) {\n  return arr.filter((item) => !!item[attr]);\n}\n\nexports.selectattr = selectattr;\n\nfunction replace(str, old, new_, maxCount) {\n  var originalStr = str;\n\n  if (old instanceof RegExp) {\n    return str.replace(old, new_);\n  }\n\n  if (typeof maxCount === 'undefined') {\n    maxCount = -1;\n  }\n\n  let res = ''; // Output\n\n  // Cast Numbers in the search term to string\n  if (typeof old === 'number') {\n    old = '' + old;\n  } else if (typeof old !== 'string') {\n    // If it is something other than number or string,\n    // return the original string\n    return str;\n  }\n\n  // Cast numbers in the replacement to string\n  if (typeof str === 'number') {\n    str = '' + str;\n  }\n\n  // If by now, we don't have a string, throw it back\n  if (typeof str !== 'string' && !(str instanceof r.SafeString)) {\n    return str;\n  }\n\n  // ShortCircuits\n  if (old === '') {\n    // Mimic the python behaviour: empty string is replaced\n    // by replacement e.g. \"abc\"|replace(\"\", \".\") -> .a.b.c.\n    res = new_ + str.split('').join(new_) + new_;\n    return r.copySafeness(str, res);\n  }\n\n  let nextIndex = str.indexOf(old);\n  // if # of replacements to perform is 0, or the string to does\n  // not contain the old value, return the string\n  if (maxCount === 0 || nextIndex === -1) {\n    return str;\n  }\n\n  let pos = 0;\n  let count = 0; // # of replacements made\n\n  while (nextIndex > -1 && (maxCount === -1 || count < maxCount)) {\n    // Grab the next chunk of src string and add it with the\n    // replacement, to the result\n    res += str.substring(pos, nextIndex) + new_;\n    // Increment our pointer in the src string\n    pos = nextIndex + old.length;\n    count++;\n    // See if there are any more replacements to be made\n    nextIndex = str.indexOf(old, pos);\n  }\n\n  // We've either reached the end, or done the max # of\n  // replacements, tack on any remaining string\n  if (pos < str.length) {\n    res += str.substring(pos);\n  }\n\n  return r.copySafeness(originalStr, res);\n}\n\nexports.replace = replace;\n\nfunction reverse(val) {\n  var arr;\n  if (lib.isString(val)) {\n    arr = list(val);\n  } else {\n    // Copy it\n    arr = lib.map(val, v => v);\n  }\n\n  arr.reverse();\n\n  if (lib.isString(val)) {\n    return r.copySafeness(val, arr.join(''));\n  }\n  return arr;\n}\n\nexports.reverse = reverse;\n\nfunction round(val, precision, method) {\n  precision = precision || 0;\n  const factor = Math.pow(10, precision);\n  let rounder;\n\n  if (method === 'ceil') {\n    rounder = Math.ceil;\n  } else if (method === 'floor') {\n    rounder = Math.floor;\n  } else {\n    rounder = Math.round;\n  }\n\n  return rounder(val * factor) / factor;\n}\n\nexports.round = round;\n\nfunction slice(arr, slices, fillWith) {\n  const sliceLength = Math.floor(arr.length / slices);\n  const extra = arr.length % slices;\n  const res = [];\n  let offset = 0;\n\n  for (let i = 0; i < slices; i++) {\n    const start = offset + (i * sliceLength);\n    if (i < extra) {\n      offset++;\n    }\n    const end = offset + ((i + 1) * sliceLength);\n\n    const currSlice = arr.slice(start, end);\n    if (fillWith && i >= extra) {\n      currSlice.push(fillWith);\n    }\n    res.push(currSlice);\n  }\n\n  return res;\n}\n\nexports.slice = slice;\n\nfunction sum(arr, attr, start = 0) {\n  if (attr) {\n    arr = lib.map(arr, (v) => v[attr]);\n  }\n\n  return start + arr.reduce((a, b) => a + b, 0);\n}\n\nexports.sum = sum;\n\nexports.sort = r.makeMacro(\n  ['value', 'reverse', 'case_sensitive', 'attribute'], [],\n  function sortFilter(arr, reversed, caseSens, attr) {\n    // Copy it\n    let array = lib.map(arr, v => v);\n    let getAttribute = lib.getAttrGetter(attr);\n\n    array.sort((a, b) => {\n      let x = (attr) ? getAttribute(a) : a;\n      let y = (attr) ? getAttribute(b) : b;\n\n      if (\n        this.env.opts.throwOnUndefined &&\n        attr && (x === undefined || y === undefined)\n      ) {\n        throw new TypeError(`sort: attribute \"${attr}\" resolved to undefined`);\n      }\n\n      if (!caseSens && lib.isString(x) && lib.isString(y)) {\n        x = x.toLowerCase();\n        y = y.toLowerCase();\n      }\n\n      if (x < y) {\n        return reversed ? 1 : -1;\n      } else if (x > y) {\n        return reversed ? -1 : 1;\n      } else {\n        return 0;\n      }\n    });\n\n    return array;\n  });\n\nfunction string(obj) {\n  return r.copySafeness(obj, obj);\n}\n\nexports.string = string;\n\nfunction striptags(input, preserveLinebreaks) {\n  input = normalize(input, '');\n  let tags = /<\\/?([a-z][a-z0-9]*)\\b[^>]*>|<!--[\\s\\S]*?-->/gi;\n  let trimmedInput = trim(input.replace(tags, ''));\n  let res = '';\n  if (preserveLinebreaks) {\n    res = trimmedInput\n      .replace(/^ +| +$/gm, '') // remove leading and trailing spaces\n      .replace(/ +/g, ' ') // squash adjacent spaces\n      .replace(/(\\r\\n)/g, '\\n') // normalize linebreaks (CRLF -> LF)\n      .replace(/\\n\\n\\n+/g, '\\n\\n'); // squash abnormal adjacent linebreaks\n  } else {\n    res = trimmedInput.replace(/\\s+/gi, ' ');\n  }\n  return r.copySafeness(input, res);\n}\n\nexports.striptags = striptags;\n\nfunction title(str) {\n  str = normalize(str, '');\n  let words = str.split(' ').map(word => capitalize(word));\n  return r.copySafeness(str, words.join(' '));\n}\n\nexports.title = title;\n\nfunction trim(str) {\n  return r.copySafeness(str, str.replace(/^\\s*|\\s*$/g, ''));\n}\n\nexports.trim = trim;\n\nfunction truncate(input, length, killwords, end) {\n  var orig = input;\n  input = normalize(input, '');\n  length = length || 255;\n\n  if (input.length <= length) {\n    return input;\n  }\n\n  if (killwords) {\n    input = input.substring(0, length);\n  } else {\n    let idx = input.lastIndexOf(' ', length);\n    if (idx === -1) {\n      idx = length;\n    }\n\n    input = input.substring(0, idx);\n  }\n\n  input += (end !== undefined && end !== null) ? end : '...';\n  return r.copySafeness(orig, input);\n}\n\nexports.truncate = truncate;\n\nfunction upper(str) {\n  str = normalize(str, '');\n  return str.toUpperCase();\n}\n\nexports.upper = upper;\n\nfunction urlencode(obj) {\n  var enc = encodeURIComponent;\n  if (lib.isString(obj)) {\n    return enc(obj);\n  } else {\n    let keyvals = (lib.isArray(obj)) ? obj : lib._entries(obj);\n    return keyvals.map(([k, v]) => `${enc(k)}=${enc(v)}`).join('&');\n  }\n}\n\nexports.urlencode = urlencode;\n\n// For the jinja regexp, see\n// https://github.com/mitsuhiko/jinja2/blob/f15b814dcba6aa12bc74d1f7d0c881d55f7126be/jinja2/utils.py#L20-L23\nconst puncRe = /^(?:\\(|<|&lt;)?(.*?)(?:\\.|,|\\)|\\n|&gt;)?$/;\n// from http://blog.gerv.net/2011/05/html5_email_address_regexp/\nconst emailRe = /^[\\w.!#$%&'*+\\-\\/=?\\^`{|}~]+@[a-z\\d\\-]+(\\.[a-z\\d\\-]+)+$/i;\nconst httpHttpsRe = /^https?:\\/\\/.*$/;\nconst wwwRe = /^www\\./;\nconst tldRe = /\\.(?:org|net|com)(?:\\:|\\/|$)/;\n\nfunction urlize(str, length, nofollow) {\n  if (isNaN(length)) {\n    length = Infinity;\n  }\n\n  const noFollowAttr = (nofollow === true ? ' rel=\"nofollow\"' : '');\n\n  const words = str.split(/(\\s+)/).filter((word) => {\n    // If the word has no length, bail. This can happen for str with\n    // trailing whitespace.\n    return word && word.length;\n  }).map((word) => {\n    var matches = word.match(puncRe);\n    var possibleUrl = (matches) ? matches[1] : word;\n    var shortUrl = possibleUrl.substr(0, length);\n\n    // url that starts with http or https\n    if (httpHttpsRe.test(possibleUrl)) {\n      return `<a href=\"${possibleUrl}\"${noFollowAttr}>${shortUrl}</a>`;\n    }\n\n    // url that starts with www.\n    if (wwwRe.test(possibleUrl)) {\n      return `<a href=\"http://${possibleUrl}\"${noFollowAttr}>${shortUrl}</a>`;\n    }\n\n    // an email address of the form username@domain.tld\n    if (emailRe.test(possibleUrl)) {\n      return `<a href=\"mailto:${possibleUrl}\">${possibleUrl}</a>`;\n    }\n\n    // url that ends in .com, .org or .net that is not an email address\n    if (tldRe.test(possibleUrl)) {\n      return `<a href=\"http://${possibleUrl}\"${noFollowAttr}>${shortUrl}</a>`;\n    }\n\n    return word;\n  });\n\n  return words.join('');\n}\n\nexports.urlize = urlize;\n\nfunction wordcount(str) {\n  str = normalize(str, '');\n  const words = (str) ? str.match(/\\w+/g) : null;\n  return (words) ? words.length : null;\n}\n\nexports.wordcount = wordcount;\n\nfunction float(val, def) {\n  var res = parseFloat(val);\n  return (isNaN(res)) ? def : res;\n}\n\nexports.float = float;\n\nconst intFilter = r.makeMacro(\n  ['value', 'default', 'base'],\n  [],\n  function doInt(value, defaultValue, base = 10) {\n    var res = parseInt(value, base);\n    return (isNaN(res)) ? defaultValue : res;\n  }\n);\n\nexports.int = intFilter;\n\n// Aliases\nexports.d = exports.default;\nexports.e = exports.escape;\n\n\n\n// WEBPACK FOOTER //\n// ./nunjucks/src/filters.js","'use strict';\n\nconst Loader = require('./loader');\n\nclass PrecompiledLoader extends Loader {\n  constructor(compiledTemplates) {\n    super();\n    this.precompiled = compiledTemplates || {};\n  }\n\n  getSource(name) {\n    if (this.precompiled[name]) {\n      return {\n        src: {\n          type: 'code',\n          obj: this.precompiled[name]\n        },\n        path: name\n      };\n    }\n    return null;\n  }\n}\n\nmodule.exports = {\n  PrecompiledLoader: PrecompiledLoader,\n};\n\n\n\n// WEBPACK FOOTER //\n// ./nunjucks/src/precompiled-loader.js","'use strict';\n\nvar SafeString = require('./runtime').SafeString;\n\n/**\n * Returns `true` if the object is a function, otherwise `false`.\n * @param { any } value\n * @returns { boolean }\n */\nfunction callable(value) {\n  return typeof value === 'function';\n}\n\nexports.callable = callable;\n\n/**\n * Returns `true` if the object is strictly not `undefined`.\n * @param { any } value\n * @returns { boolean }\n */\nfunction defined(value) {\n  return value !== undefined;\n}\n\nexports.defined = defined;\n\n/**\n * Returns `true` if the operand (one) is divisble by the test's argument\n * (two).\n * @param { number } one\n * @param { number } two\n * @returns { boolean }\n */\nfunction divisibleby(one, two) {\n  return (one % two) === 0;\n}\n\nexports.divisibleby = divisibleby;\n\n/**\n * Returns true if the string has been escaped (i.e., is a SafeString).\n * @param { any } value\n * @returns { boolean }\n */\nfunction escaped(value) {\n  return value instanceof SafeString;\n}\n\nexports.escaped = escaped;\n\n/**\n * Returns `true` if the arguments are strictly equal.\n * @param { any } one\n * @param { any } two\n */\nfunction equalto(one, two) {\n  return one === two;\n}\n\nexports.equalto = equalto;\n\n// Aliases\nexports.eq = exports.equalto;\nexports.sameas = exports.equalto;\n\n/**\n * Returns `true` if the value is evenly divisible by 2.\n * @param { number } value\n * @returns { boolean }\n */\nfunction even(value) {\n  return value % 2 === 0;\n}\n\nexports.even = even;\n\n/**\n * Returns `true` if the value is falsy - if I recall correctly, '', 0, false,\n * undefined, NaN or null. I don't know if we should stick to the default JS\n * behavior or attempt to replicate what Python believes should be falsy (i.e.,\n * empty arrays, empty dicts, not 0...).\n * @param { any } value\n * @returns { boolean }\n */\nfunction falsy(value) {\n  return !value;\n}\n\nexports.falsy = falsy;\n\n/**\n * Returns `true` if the operand (one) is greater or equal to the test's\n * argument (two).\n * @param { number } one\n * @param { number } two\n * @returns { boolean }\n */\nfunction ge(one, two) {\n  return one >= two;\n}\n\nexports.ge = ge;\n\n/**\n * Returns `true` if the operand (one) is greater than the test's argument\n * (two).\n * @param { number } one\n * @param { number } two\n * @returns { boolean }\n */\nfunction greaterthan(one, two) {\n  return one > two;\n}\n\nexports.greaterthan = greaterthan;\n\n// alias\nexports.gt = exports.greaterthan;\n\n/**\n * Returns `true` if the operand (one) is less than or equal to the test's\n * argument (two).\n * @param { number } one\n * @param { number } two\n * @returns { boolean }\n */\nfunction le(one, two) {\n  return one <= two;\n}\n\nexports.le = le;\n\n/**\n * Returns `true` if the operand (one) is less than the test's passed argument\n * (two).\n * @param { number } one\n * @param { number } two\n * @returns { boolean }\n */\nfunction lessthan(one, two) {\n  return one < two;\n}\n\nexports.lessthan = lessthan;\n\n// alias\nexports.lt = exports.lessthan;\n\n/**\n * Returns `true` if the string is lowercased.\n * @param { string } value\n * @returns { boolean }\n */\nfunction lower(value) {\n  return value.toLowerCase() === value;\n}\n\nexports.lower = lower;\n\n/**\n * Returns `true` if the operand (one) is less than or equal to the test's\n * argument (two).\n * @param { number } one\n * @param { number } two\n * @returns { boolean }\n */\nfunction ne(one, two) {\n  return one !== two;\n}\n\nexports.ne = ne;\n\n/**\n * Returns true if the value is strictly equal to `null`.\n * @param { any }\n * @returns { boolean }\n */\nfunction nullTest(value) {\n  return value === null;\n}\n\nexports.null = nullTest;\n\n/**\n * Returns true if value is a number.\n * @param { any }\n * @returns { boolean }\n */\nfunction number(value) {\n  return typeof value === 'number';\n}\n\nexports.number = number;\n\n/**\n * Returns `true` if the value is *not* evenly divisible by 2.\n * @param { number } value\n * @returns { boolean }\n */\nfunction odd(value) {\n  return value % 2 === 1;\n}\n\nexports.odd = odd;\n\n/**\n * Returns `true` if the value is a string, `false` if not.\n * @param { any } value\n * @returns { boolean }\n */\nfunction string(value) {\n  return typeof value === 'string';\n}\n\nexports.string = string;\n\n/**\n * Returns `true` if the value is not in the list of things considered falsy:\n * '', null, undefined, 0, NaN and false.\n * @param { any } value\n * @returns { boolean }\n */\nfunction truthy(value) {\n  return !!value;\n}\n\nexports.truthy = truthy;\n\n/**\n * Returns `true` if the value is undefined.\n * @param { any } value\n * @returns { boolean }\n */\nfunction undefinedTest(value) {\n  return value === undefined;\n}\n\nexports.undefined = undefinedTest;\n\n/**\n * Returns `true` if the string is uppercased.\n * @param { string } value\n * @returns { boolean }\n */\nfunction upper(value) {\n  return value.toUpperCase() === value;\n}\n\nexports.upper = upper;\n\n/**\n * If ES6 features are available, returns `true` if the value implements the\n * `Symbol.iterator` method. If not, it's a string or Array.\n *\n * Could potentially cause issues if a browser exists that has Set and Map but\n * not Symbol.\n *\n * @param { any } value\n * @returns { boolean }\n */\nfunction iterable(value) {\n  if (typeof Symbol !== 'undefined') {\n    return !!value[Symbol.iterator];\n  } else {\n    return Array.isArray(value) || typeof value === 'string';\n  }\n}\n\nexports.iterable = iterable;\n\n/**\n * If ES6 features are available, returns `true` if the value is an object hash\n * or an ES6 Map. Otherwise just return if it's an object hash.\n * @param { any } value\n * @returns { boolean }\n */\nfunction mapping(value) {\n  // only maps and object hashes\n  var bool = value !== null\n    && value !== undefined\n    && typeof value === 'object'\n    && !Array.isArray(value);\n  if (Set) {\n    return bool && !(value instanceof Set);\n  } else {\n    return bool;\n  }\n}\n\nexports.mapping = mapping;\n\n\n\n// WEBPACK FOOTER //\n// ./nunjucks/src/tests.js","'use strict';\n\nfunction cycler(items) {\n  var index = -1;\n\n  return {\n    current: null,\n    reset() {\n      index = -1;\n      this.current = null;\n    },\n\n    next() {\n      index++;\n      if (index >= items.length) {\n        index = 0;\n      }\n\n      this.current = items[index];\n      return this.current;\n    },\n  };\n}\n\nfunction joiner(sep) {\n  sep = sep || ',';\n  let first = true;\n\n  return () => {\n    const val = first ? '' : sep;\n    first = false;\n    return val;\n  };\n}\n\n// Making this a function instead so it returns a new object\n// each time it's called. That way, if something like an environment\n// uses it, they will each have their own copy.\nfunction globals() {\n  return {\n    range(start, stop, step) {\n      if (typeof stop === 'undefined') {\n        stop = start;\n        start = 0;\n        step = 1;\n      } else if (!step) {\n        step = 1;\n      }\n\n      const arr = [];\n      if (step > 0) {\n        for (let i = start; i < stop; i += step) {\n          arr.push(i);\n        }\n      } else {\n        for (let i = start; i > stop; i += step) { // eslint-disable-line for-direction\n          arr.push(i);\n        }\n      }\n      return arr;\n    },\n\n    cycler() {\n      return cycler(Array.prototype.slice.call(arguments));\n    },\n\n    joiner(sep) {\n      return joiner(sep);\n    }\n  };\n}\n\nmodule.exports = globals;\n\n\n\n// WEBPACK FOOTER //\n// ./nunjucks/src/globals.js","const path = require('path');\n\nmodule.exports = function express(env, app) {\n  function NunjucksView(name, opts) {\n    this.name = name;\n    this.path = name;\n    this.defaultEngine = opts.defaultEngine;\n    this.ext = path.extname(name);\n    if (!this.ext && !this.defaultEngine) {\n      throw new Error('No default engine was specified and no extension was provided.');\n    }\n    if (!this.ext) {\n      this.name += (this.ext = (this.defaultEngine[0] !== '.' ? '.' : '') + this.defaultEngine);\n    }\n  }\n\n  NunjucksView.prototype.render = function render(opts, cb) {\n    env.render(this.name, opts, cb);\n  };\n\n  app.set('view', NunjucksView);\n  app.set('nunjucksEnv', env);\n  return env;\n};\n\n\n\n// WEBPACK FOOTER //\n// ./nunjucks/src/express-app.js","'use strict';\n\nconst fs = require('fs');\nconst path = require('path');\nconst {_prettifyError} = require('./lib');\nconst compiler = require('./compiler');\nconst {Environment} = require('./environment');\nconst precompileGlobal = require('./precompile-global');\n\nfunction match(filename, patterns) {\n  if (!Array.isArray(patterns)) {\n    return false;\n  }\n  return patterns.some((pattern) => filename.match(pattern));\n}\n\nfunction precompileString(str, opts) {\n  opts = opts || {};\n  opts.isString = true;\n  const env = opts.env || new Environment([]);\n  const wrapper = opts.wrapper || precompileGlobal;\n\n  if (!opts.name) {\n    throw new Error('the \"name\" option is required when compiling a string');\n  }\n  return wrapper([_precompile(str, opts.name, env)], opts);\n}\n\nfunction precompile(input, opts) {\n  // The following options are available:\n  //\n  // * name: name of the template (auto-generated when compiling a directory)\n  // * isString: input is a string, not a file path\n  // * asFunction: generate a callable function\n  // * force: keep compiling on error\n  // * env: the Environment to use (gets extensions and async filters from it)\n  // * include: which file/folders to include (folders are auto-included, files are auto-excluded)\n  // * exclude: which file/folders to exclude (folders are auto-included, files are auto-excluded)\n  // * wrapper: function(templates, opts) {...}\n  //       Customize the output format to store the compiled template.\n  //       By default, templates are stored in a global variable used by the runtime.\n  //       A custom loader will be necessary to load your custom wrapper.\n\n  opts = opts || {};\n  const env = opts.env || new Environment([]);\n  const wrapper = opts.wrapper || precompileGlobal;\n\n  if (opts.isString) {\n    return precompileString(input, opts);\n  }\n\n  const pathStats = fs.existsSync(input) && fs.statSync(input);\n  const precompiled = [];\n  const templates = [];\n\n  function addTemplates(dir) {\n    fs.readdirSync(dir).forEach((file) => {\n      const filepath = path.join(dir, file);\n      let subpath = filepath.substr(path.join(input, '/').length);\n      const stat = fs.statSync(filepath);\n\n      if (stat && stat.isDirectory()) {\n        subpath += '/';\n        if (!match(subpath, opts.exclude)) {\n          addTemplates(filepath);\n        }\n      } else if (match(subpath, opts.include)) {\n        templates.push(filepath);\n      }\n    });\n  }\n\n  if (pathStats.isFile()) {\n    precompiled.push(_precompile(\n      fs.readFileSync(input, 'utf-8'),\n      opts.name || input,\n      env\n    ));\n  } else if (pathStats.isDirectory()) {\n    addTemplates(input);\n\n    for (let i = 0; i < templates.length; i++) {\n      const name = templates[i].replace(path.join(input, '/'), '');\n\n      try {\n        precompiled.push(_precompile(\n          fs.readFileSync(templates[i], 'utf-8'),\n          name,\n          env\n        ));\n      } catch (e) {\n        if (opts.force) {\n          // Don't stop generating the output if we're\n          // forcing compilation.\n          console.error(e); // eslint-disable-line no-console\n        } else {\n          throw e;\n        }\n      }\n    }\n  }\n\n  return wrapper(precompiled, opts);\n}\n\nfunction _precompile(str, name, env) {\n  env = env || new Environment([]);\n\n  const asyncFilters = env.asyncFilters;\n  const extensions = env.extensionsList;\n  let template;\n\n  name = name.replace(/\\\\/g, '/');\n\n  try {\n    template = compiler.compile(str,\n      asyncFilters,\n      extensions,\n      name,\n      env.opts);\n  } catch (err) {\n    throw _prettifyError(name, false, err);\n  }\n\n  return {\n    name: name,\n    template: template\n  };\n}\n\nmodule.exports = {\n  precompile: precompile,\n  precompileString: precompileString\n};\n\n\n\n// WEBPACK FOOTER //\n// ./nunjucks/src/precompile.js","'use strict';\n\nfunction precompileGlobal(templates, opts) {\n  var out = '';\n  opts = opts || {};\n\n  for (let i = 0; i < templates.length; i++) {\n    const name = JSON.stringify(templates[i].name);\n    const template = templates[i].template;\n\n    out += '(function() {' +\n      '(window.nunjucksPrecompiled = window.nunjucksPrecompiled || {})' +\n      '[' + name + '] = (function() {\\n' + template + '\\n})();\\n';\n\n    if (opts.asFunction) {\n      out += 'return function(ctx, cb) { return nunjucks.render(' + name + ', ctx, cb); }\\n';\n    }\n\n    out += '})();\\n';\n  }\n  return out;\n}\n\nmodule.exports = precompileGlobal;\n\n\n\n// WEBPACK FOOTER //\n// ./nunjucks/src/precompile-global.js","function installCompat() {\n  'use strict';\n\n  /* eslint-disable camelcase */\n\n  // This must be called like `nunjucks.installCompat` so that `this`\n  // references the nunjucks instance\n  var runtime = this.runtime;\n  var lib = this.lib;\n  // Handle slim case where these 'modules' are excluded from the built source\n  var Compiler = this.compiler.Compiler;\n  var Parser = this.parser.Parser;\n  var nodes = this.nodes;\n  var lexer = this.lexer;\n\n  var orig_contextOrFrameLookup = runtime.contextOrFrameLookup;\n  var orig_memberLookup = runtime.memberLookup;\n  var orig_Compiler_assertType;\n  var orig_Parser_parseAggregate;\n  if (Compiler) {\n    orig_Compiler_assertType = Compiler.prototype.assertType;\n  }\n  if (Parser) {\n    orig_Parser_parseAggregate = Parser.prototype.parseAggregate;\n  }\n\n  function uninstall() {\n    runtime.contextOrFrameLookup = orig_contextOrFrameLookup;\n    runtime.memberLookup = orig_memberLookup;\n    if (Compiler) {\n      Compiler.prototype.assertType = orig_Compiler_assertType;\n    }\n    if (Parser) {\n      Parser.prototype.parseAggregate = orig_Parser_parseAggregate;\n    }\n  }\n\n  runtime.contextOrFrameLookup = function contextOrFrameLookup(context, frame, key) {\n    var val = orig_contextOrFrameLookup.apply(this, arguments);\n    if (val !== undefined) {\n      return val;\n    }\n    switch (key) {\n      case 'True':\n        return true;\n      case 'False':\n        return false;\n      case 'None':\n        return null;\n      default:\n        return undefined;\n    }\n  };\n\n  function getTokensState(tokens) {\n    return {\n      index: tokens.index,\n      lineno: tokens.lineno,\n      colno: tokens.colno\n    };\n  }\n\n  if (process.env.BUILD_TYPE !== 'SLIM' && nodes && Compiler && Parser) { // i.e., not slim mode\n    const Slice = nodes.Node.extend('Slice', {\n      fields: ['start', 'stop', 'step'],\n      init(lineno, colno, start, stop, step) {\n        start = start || new nodes.Literal(lineno, colno, null);\n        stop = stop || new nodes.Literal(lineno, colno, null);\n        step = step || new nodes.Literal(lineno, colno, 1);\n        this.parent(lineno, colno, start, stop, step);\n      }\n    });\n\n    Compiler.prototype.assertType = function assertType(node) {\n      if (node instanceof Slice) {\n        return;\n      }\n      orig_Compiler_assertType.apply(this, arguments);\n    };\n    Compiler.prototype.compileSlice = function compileSlice(node, frame) {\n      this._emit('(');\n      this._compileExpression(node.start, frame);\n      this._emit('),(');\n      this._compileExpression(node.stop, frame);\n      this._emit('),(');\n      this._compileExpression(node.step, frame);\n      this._emit(')');\n    };\n\n    Parser.prototype.parseAggregate = function parseAggregate() {\n      var origState = getTokensState(this.tokens);\n      // Set back one accounting for opening bracket/parens\n      origState.colno--;\n      origState.index--;\n      try {\n        return orig_Parser_parseAggregate.apply(this);\n      } catch (e) {\n        const errState = getTokensState(this.tokens);\n        const rethrow = () => {\n          lib._assign(this.tokens, errState);\n          return e;\n        };\n\n        // Reset to state before original parseAggregate called\n        lib._assign(this.tokens, origState);\n        this.peeked = false;\n\n        const tok = this.peekToken();\n        if (tok.type !== lexer.TOKEN_LEFT_BRACKET) {\n          throw rethrow();\n        } else {\n          this.nextToken();\n        }\n\n        const node = new Slice(tok.lineno, tok.colno);\n\n        // If we don't encounter a colon while parsing, this is not a slice,\n        // so re-raise the original exception.\n        let isSlice = false;\n\n        for (let i = 0; i <= node.fields.length; i++) {\n          if (this.skip(lexer.TOKEN_RIGHT_BRACKET)) {\n            break;\n          }\n          if (i === node.fields.length) {\n            if (isSlice) {\n              this.fail('parseSlice: too many slice components', tok.lineno, tok.colno);\n            } else {\n              break;\n            }\n          }\n          if (this.skip(lexer.TOKEN_COLON)) {\n            isSlice = true;\n          } else {\n            const field = node.fields[i];\n            node[field] = this.parseExpression();\n            isSlice = this.skip(lexer.TOKEN_COLON) || isSlice;\n          }\n        }\n        if (!isSlice) {\n          throw rethrow();\n        }\n        return new nodes.Array(tok.lineno, tok.colno, [node]);\n      }\n    };\n  }\n\n  function sliceLookup(obj, start, stop, step) {\n    obj = obj || [];\n    if (start === null) {\n      start = (step < 0) ? (obj.length - 1) : 0;\n    }\n    if (stop === null) {\n      stop = (step < 0) ? -1 : obj.length;\n    } else if (stop < 0) {\n      stop += obj.length;\n    }\n\n    if (start < 0) {\n      start += obj.length;\n    }\n\n    const results = [];\n\n    for (let i = start; ; i += step) {\n      if (i < 0 || i > obj.length) {\n        break;\n      }\n      if (step > 0 && i >= stop) {\n        break;\n      }\n      if (step < 0 && i <= stop) {\n        break;\n      }\n      results.push(runtime.memberLookup(obj, i));\n    }\n    return results;\n  }\n\n  function hasOwnProp(obj, key) {\n    return Object.prototype.hasOwnProperty.call(obj, key);\n  }\n\n  const ARRAY_MEMBERS = {\n    pop(index) {\n      if (index === undefined) {\n        return this.pop();\n      }\n      if (index >= this.length || index < 0) {\n        throw new Error('KeyError');\n      }\n      return this.splice(index, 1);\n    },\n    append(element) {\n      return this.push(element);\n    },\n    remove(element) {\n      for (let i = 0; i < this.length; i++) {\n        if (this[i] === element) {\n          return this.splice(i, 1);\n        }\n      }\n      throw new Error('ValueError');\n    },\n    count(element) {\n      var count = 0;\n      for (let i = 0; i < this.length; i++) {\n        if (this[i] === element) {\n          count++;\n        }\n      }\n      return count;\n    },\n    index(element) {\n      var i;\n      if ((i = this.indexOf(element)) === -1) {\n        throw new Error('ValueError');\n      }\n      return i;\n    },\n    find(element) {\n      return this.indexOf(element);\n    },\n    insert(index, elem) {\n      return this.splice(index, 0, elem);\n    }\n  };\n  const OBJECT_MEMBERS = {\n    items() {\n      return lib._entries(this);\n    },\n    values() {\n      return lib._values(this);\n    },\n    keys() {\n      return lib.keys(this);\n    },\n    get(key, def) {\n      var output = this[key];\n      if (output === undefined) {\n        output = def;\n      }\n      return output;\n    },\n    has_key(key) {\n      return hasOwnProp(this, key);\n    },\n    pop(key, def) {\n      var output = this[key];\n      if (output === undefined && def !== undefined) {\n        output = def;\n      } else if (output === undefined) {\n        throw new Error('KeyError');\n      } else {\n        delete this[key];\n      }\n      return output;\n    },\n    popitem() {\n      const keys = lib.keys(this);\n      if (!keys.length) {\n        throw new Error('KeyError');\n      }\n      const k = keys[0];\n      const val = this[k];\n      delete this[k];\n      return [k, val];\n    },\n    setdefault(key, def = null) {\n      if (!(key in this)) {\n        this[key] = def;\n      }\n      return this[key];\n    },\n    update(kwargs) {\n      lib._assign(this, kwargs);\n      return null; // Always returns None\n    }\n  };\n  OBJECT_MEMBERS.iteritems = OBJECT_MEMBERS.items;\n  OBJECT_MEMBERS.itervalues = OBJECT_MEMBERS.values;\n  OBJECT_MEMBERS.iterkeys = OBJECT_MEMBERS.keys;\n\n  runtime.memberLookup = function memberLookup(obj, val, autoescape) {\n    if (arguments.length === 4) {\n      return sliceLookup.apply(this, arguments);\n    }\n    obj = obj || {};\n\n    // If the object is an object, return any of the methods that Python would\n    // otherwise provide.\n    if (lib.isArray(obj) && hasOwnProp(ARRAY_MEMBERS, val)) {\n      return ARRAY_MEMBERS[val].bind(obj);\n    }\n    if (lib.isObject(obj) && hasOwnProp(OBJECT_MEMBERS, val)) {\n      return OBJECT_MEMBERS[val].bind(obj);\n    }\n\n    return orig_memberLookup.apply(this, arguments);\n  };\n\n  return uninstall;\n}\n\nmodule.exports = installCompat;\n\n\n\n// WEBPACK FOOTER //\n// ./nunjucks/src/jinja-compat.js"],"sourceRoot":""}