1 line
328 KiB
Plaintext
1 line
328 KiB
Plaintext
{"version":3,"sources":["../webpack/universalModuleDefinition","../webpack/bootstrap c1b088ecfcbffa181d21","../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","_defineProperties","target","props","descriptor","arg","input","hint","prim","Symbol","toPrimitive","res","String","Number","_toPrimitive","_createClass","Constructor","protoProps","staticProps","_inheritsLoose","subClass","superClass","_setPrototypeOf","bind","__proto__","EventEmitter","require","lib","extendClass","cls","parent","prop","tmp","apply","subclass","_cls","Obj","init","EmitterObj","_EventEmitter","_this2","_this","arrayFrom","from","supportsIterators","Frame","isolateWrites","variables","topLevel","_proto","set","resolveUp","frame","resolve","id","lookup","forWrite","pop","isKeywordArgs","numArgs","args","SafeString","valueOf","makeMacro","argNames","kwargNames","_len","macroArgs","_key","argCount","kwargs","lastArg","getKeywordArgs","makeKeywordArgs","__keywords","suppressValue","autoescape","ensureDefined","memberLookup","_len2","_key2","contextOrFrameLookup","callWrap","handleError","error","copySafeness","dest","markSafe","type","ret","asyncEach","dimen","asyncAll","outputArr","finished","done","output","join","fromIterator","traverseAndCheck","Node","findAll","_Obj","_arguments","fields","field","NodeList","children","child","iterFields","_this3","Value","_Node","_Node2","_proto2","nodes","addChild","node","Root","Literal","Group","ArrayNode","Pair","Dict","LookupVal","If","IfAsync","InlineIf","For","AsyncEach","AsyncAll","Macro","Caller","Import","FromImport","_Node3","template","names","withContext","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","to","dirname","isRelative","filename","asap","waterfall","compiler","filters","_require","FileSystemLoader","WebLoader","PrecompiledLoader","tests","globals","_require2","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","_Obj2","_proto3","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","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","_Loader","baseURL","useCache","fetch","content","status","url","ajax","XMLHttpRequest","loading","onreadystatechange","readyState","responseText","Date","getTime","open","send","precompile","installJinjaCompat","configure","templatesPath","TemplateLoader","watch","web","NodeResolveLoader","reset","precompileString","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","isNaN","once","emitter","Promise","reject","errorListener","removeListener","resolver","eventTargetAgnosticAddListener","handler","addErrorHandlerIfEventEmitter","_events","_eventsCount","_maxListeners","defaultMaxListeners","checkListener","listener","_getMaxListeners","_addListener","prepend","events","existing","newListener","warned","w","count","console","warn","_onceWrap","state","fired","wrapFn","_listeners","unwrap","evlistener","unwrapListeners","arrayClone","listenerCount","copy","addEventListener","wrapListener","removeEventListener","RangeError","getPrototypeOf","setMaxListeners","getMaxListeners","doError","er","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","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 c1b088ecfcbffa181d21","'use strict';\n\nvar ArrayProto = Array.prototype;\nvar ObjProto = Object.prototype;\n\nvar escapeMap = {\n '&': '&',\n '\"': '"',\n '\\'': ''',\n '<': '<',\n '>': '>',\n '\\\\': '\',\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 errorListener(err) {\n emitter.removeListener(name, resolver);\n reject(err);\n }\n\n function resolver() {\n if (typeof emitter.removeListener === 'function') {\n emitter.removeListener('error', errorListener);\n }\n resolve([].slice.call(arguments));\n };\n\n eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });\n if (name !== 'error') {\n addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });\n }\n });\n}\n\nfunction addErrorHandlerIfEventEmitter(emitter, handler, flags) {\n if (typeof emitter.on === 'function') {\n eventTargetAgnosticAddListener(emitter, 'error', handler, flags);\n }\n}\n\nfunction eventTargetAgnosticAddListener(emitter, name, listener, flags) {\n if (typeof emitter.on === 'function') {\n if (flags.once) {\n emitter.once(name, listener);\n } else {\n emitter.on(name, listener);\n }\n } else if (typeof emitter.addEventListener === 'function') {\n // EventTarget does not have `error` event semantics like Node\n // EventEmitters, we do not listen for `error` events here.\n emitter.addEventListener(name, function wrapListener(arg) {\n // IE does not have builtin `{ once: true }` support so we\n // have to do it manually.\n if (flags.once) {\n emitter.removeEventListener(name, wrapListener);\n }\n listener(arg);\n });\n } else {\n throw new TypeError('The \"emitter\" argument must be of type EventEmitter. Received type ' + typeof emitter);\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 = /^(?:\\(|<|<)?(.*?)(?:\\.|,|\\)|\\n|>)?$/;\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":""} |