npm - @knight-lab/timelinejs - Versions diffs - 3.9.7 → 3.9.9 - Mend

@knight-lab/timelinejs 3.9.7 → 3.9.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2593) hide show

package/eleventy/node_modules/nunjucks/browser/nunjucks.min.js.map DELETED Viewed

@@ -1 +0,0 @@

- {"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[^>]*>|/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":""}