SmartMirror-Projektarbeit/vendor/node_modules/nunjucks/browser/nunjucks.min.js.map

{"version":3,"sources":["../webpack/universalModuleDefinition","../webpack/bootstrap 2f5efde3ab5c413a49c2","../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":["root","factory","exports","module","define","amd","self","this","installedModules","__webpack_require__","moduleId","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","configurable","enumerable","get","n","__esModule","object","property","prototype","hasOwnProperty","p","s","ArrayProto","Array","ObjProto","escapeMap","&","\"","'","<",">","escapeRegex","hasOwnProp","obj","k","lookupEscape","ch","TemplateError","message","lineno","colno","err","cause","getStack","Error","setPrototypeOf","writable","value","captureStackTrace","constructor","stackDescriptor","getOwnPropertyDescriptor","stack","firstUpdate","Update","path","msg","isFunction","toString","isArray","isString","isObject","getAttrGetter","attribute","attr","parts","split","item","_item","length","part","toArray","slice","indexOf","arr","searchElement","fromIndex","keys_","push","_prettifyError","withInternals","old","create","escape","val","replace","groupBy","throwOnUndefined","result","iterator","key","undefined","TypeError","without","array","contains","arguments","index","repeat","char_","str","each","func","context","forEach","map","results","asyncIter","iter","cb","next","asyncFor","keys","len","_entries","_values","_assign","extend","obj1","obj2","inOperator","EventEmitter","require","lib","extendClass","cls","props","parent","prop","tmp","res","apply","subclass","_cls","_inheritsLoose","_createClass","Obj","init","EmitterObj","_this2","_this","_EventEmitter","arrayFrom","from","supportsIterators","Symbol","Frame","isolateWrites","variables","topLevel","set","resolveUp","frame","resolve","id","lookup","forWrite","pop","isKeywordArgs","numArgs","args","SafeString","String","valueOf","makeMacro","argNames","kwargNames","_len","macroArgs","_key","argCount","kwargs","lastArg","getKeywordArgs","arg","makeKeywordArgs","__keywords","suppressValue","autoescape","ensureDefined","memberLookup","_len2","_key2","contextOrFrameLookup","callWrap","handleError","error","copySafeness","dest","target","markSafe","type","ret","asyncEach","dimen","asyncAll","outputArr","finished","done","output","join","fromIterator","traverseAndCheck","Node","findAll","_arguments","fields","field","NodeList","children","child","iterFields","_this3","Value","nodes","_Node2","addChild","node","Root","Literal","Group","ArrayNode","Pair","Dict","LookupVal","If","IfAsync","InlineIf","For","AsyncEach","AsyncAll","Macro","Caller","Import","FromImport","template","names","withContext","_Node3","FunCall","Filter","FilterAsync","KeywordArgs","Block","Super","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","_ref","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","_this4","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","_this5","expr","ops","op","compileLookupVal","_getNodeName","compileFunCall","compileFilter","compileFilterAsync","symbol","compileKeywordArgs","compileSet","_this6","ids","targets","charAt","compileSwitch","_this7","cases","default","compileIf","_this8","compileIfAsync","_emitLoopBindings","_this9","b","compileFor","_this10","u","tid","_node$name$children","_compileAsyncLoop","parallel","_this11","asyncMethod","arrayLen","buf","compileAsyncEach","compileAsyncAll","_compileMacro","_this12","funcId","keepFrame","currFrame","realNames","concat","pair","bufferId","compileMacro","compileCaller","_compileGetTemplate","eagerCompile","ignoreMissing","parentTemplateId","parentName","eagerCompileArg","ignoreMissingArg","compileImport","compileFromImport","_this13","importedId","nameNode","alias","compileBlock","compileSuper","blockName","compileExtends","compileInclude","id2","compileTemplateData","compileCapture","_this14","compileOutput","_this15","compileRoot","_this16","blockNames","blocks","block","tmpFrame","_compile","getCode","src","asyncFilters","extensions","opts","processedSrc","preprocess","filter","f","reduce","processor","transform","parse","_EmitterObj","Loader","_proto","to","dirname","isRelative","filename","asap","waterfall","compiler","filters","FileSystemLoader","WebLoader","PrecompiledLoader","tests","globals","globalRuntime","expressApp","callbackAsap","noopTmplSrc","env","runtime","e","Environment","loaders","dev","trimBlocks","lstripBlocks","window","nunjucksPrecompiled","unshift","_initLoaders","extensionsList","addFilter","_ref2","test","addTest","loader","cache","on","fullname","emit","source","invalidateCache","addExtension","extension","removeExtension","getExtension","hasExtension","addGlobal","getGlobal","wrapped","getFilter","getTest","resolveTemplate","getTemplate","syncResult","that","tmpl","raw","Template","handle","getSource","info","newTmpl","noCache","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","endBlock","forTok","parsePrimary","TOKEN_COMMA","prim","parseExpression","parseUntilBlocks","parseMacro","macroTok","parseSignature","parseCall","callTok","callerArgs","macroCall","callerName","callerNode","parseWithContext","parseImport","importTok","parseFrom","fromTok","nextTok","parseBlock","tag","parseExtends","parseInclude","parseIf","parseSet","TOKEN_OPERATOR","parseSwitch","defaultCase","col","parseStatement","parseRaw","parseFilterStatement","tagName","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","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","BLOCK_START","BLOCK_END","token","Tokenizer","in_code","blockStart","blockEnd","variableStart","variableEnd","commentStart","commentEnd","cur","current","isFinished","_parseString","_extract","_extractString","forward","back","forwardN","regexBody","previous","POSSIBLE_FLAGS","regexFlags","complexOps","curComplex","_extractUntil","whitespaceChars","match","beginChars","inComment","_matches","lastLine","delimiter","charString","_extractMatching","breakOnMatch","first","regex","currentStr","lastIndexOf","substr","TOKEN_SPECIAL","baseURL","_Loader","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","rawAsap","freeTasks","pendingErrors","requestErrorThrow","makeRequestCallFromTimer","shift","task","rawTask","RawTask","onerror","global","queue","requestFlush","capacity","flush","currentIndex","scan","newLength","toggle","observer","scope","BrowserMutationObserver","MutationObserver","WebKitMutationObserver","timeoutHandle","setTimeout","handleTimer","intervalHandle","setInterval","clearTimeout","clearInterval","document","createTextNode","observe","characterData","g","eval","__WEBPACK_AMD_DEFINE_RESULT__","executeSync","splice","executeAsync","fn","setImmediate","nextTick","_isArray","maybeArray","wrapIterator","makeCallback","makeIterator","ReflectOwnKeys","R","Reflect","ReflectApply","receiver","ownKeys","getOwnPropertySymbols","getOwnPropertyNames","NumberIsNaN","Number","isNaN","once","emitter","Promise","reject","eventListener","errorListener","removeListener","_events","_eventsCount","_maxListeners","defaultMaxListeners","checkListener","listener","_getMaxListeners","_addListener","prepend","events","existing","newListener","warned","w","count","console","warn","_onceWrap","state","fired","wrapFn","bind","_listeners","unwrap","evlistener","unwrapListeners","arrayClone","listenerCount","copy","RangeError","getPrototypeOf","setMaxListeners","getMaxListeners","doError","er","handler","listeners","addListener","prependListener","prependOnceListener","list","position","originalListener","spliceOne","off","removeAllListeners","rawListeners","eventNames","sym","gensym","mapCOW","walk","ast","depthFirst","astT","propsT","depthWalk","_liftFilters","walked","descNode","cps","convertStatements","blockNode","hasSuper","liftSuper","liftFilters","r","normalize","defaultValue","num","capitalize","toLowerCase","toUpperCase","getSelectOrReject","expectedTestResult","testName","secondArg","trim","abs","Math","batch","linecount","fillWith","center","width","spaces","post","def","bool","dictsort","caseSensitive","by","si","sort","t1","t2","a","dump","safe","forceescape","groupby","indentfirst","sp","del","last","Map","size","lower","nl2br","random","floor","rejectattr","select","selectattr","new_","maxCount","originalStr","nextIndex","pos","substring","reverse","round","precision","method","factor","pow","ceil","slices","sliceLength","extra","offset","start","end","currSlice","sum","reversed","caseSens","getAttribute","x","y","string","striptags","input","preserveLinebreaks","trimmedInput","title","words","word","truncate","killwords","orig","upper","urlencode","enc","encodeURIComponent","puncRe","emailRe","httpHttpsRe","wwwRe","tldRe","urlize","nofollow","Infinity","noFollowAttr","possibleUrl","shortUrl","wordcount","float","intFilter","base","int","compiledTemplates","precompiled","callable","defined","divisibleby","one","two","escaped","equalto","eq","sameas","even","falsy","ge","greaterthan","gt","le","lessthan","lt","ne","null","number","odd","truthy","iterable","mapping","range","stop","step","cycler","items","joiner","sep","NunjucksView","defaultEngine","extname","fs","precompileGlobal","patterns","pattern","wrapper","_precompile","pathStats","existsSync","statSync","templates","isFile","readFileSync","isDirectory","addTemplates","dir","readdirSync","file","filepath","subpath","stat","exclude","include","force","out","asFunction","orig_Compiler_assertType","orig_Parser_parseAggregate","orig_contextOrFrameLookup","orig_memberLookup","getTokensState","Slice","compileSlice","origState","errState","rethrow","isSlice","ARRAY_MEMBERS","append","element","remove","find","insert","elem","OBJECT_MEMBERS","values","has_key","popitem","setdefault","update","iteritems","itervalues","iterkeys"],"mappings":"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","file":"nunjucks.min.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 2f5efde3ab5c413a49c2","'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":""}