{"version":3,"sources":["webpack://Twig/webpack/universalModuleDefinition","webpack://Twig/webpack/bootstrap","webpack://Twig/./node_modules/@babel/runtime/helpers/interopRequireDefault.js","webpack://Twig/./node_modules/@babel/runtime/helpers/typeof.js","webpack://Twig/./node_modules/@babel/runtime/helpers/defineProperty.js","webpack://Twig/./node_modules/@babel/runtime/helpers/arrayLikeToArray.js","webpack://Twig/./node_modules/locutus/php/strings/sprintf.js","webpack://Twig/./node_modules/locutus/php/_helpers/_php_cast_int.js","webpack://Twig/./node_modules/path-browserify/index.js","webpack://Twig/./src/twig.js","webpack://Twig/./src/twig.factory.js","webpack://Twig/./src/twig.core.js","webpack://Twig/./src/twig.compiler.js","webpack://Twig/./src/twig.expression.js","webpack://Twig/./node_modules/@babel/runtime/helpers/toConsumableArray.js","webpack://Twig/./node_modules/@babel/runtime/helpers/arrayWithoutHoles.js","webpack://Twig/./node_modules/@babel/runtime/helpers/iterableToArray.js","webpack://Twig/./node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js","webpack://Twig/./node_modules/@babel/runtime/helpers/nonIterableSpread.js","webpack://Twig/./src/twig.expression.operator.js","webpack://Twig/./src/twig.filters.js","webpack://Twig/./src/twig.functions.js","webpack://Twig/./src/twig.lib.js","webpack://Twig/./node_modules/locutus/php/strings/vsprintf.js","webpack://Twig/./node_modules/locutus/php/math/round.js","webpack://Twig/./node_modules/locutus/php/_helpers/_php_cast_float.js","webpack://Twig/./node_modules/locutus/php/math/max.js","webpack://Twig/./node_modules/locutus/php/math/min.js","webpack://Twig/./node_modules/locutus/php/strings/strip_tags.js","webpack://Twig/./node_modules/locutus/php/_helpers/_phpCastString.js","webpack://Twig/./node_modules/locutus/php/datetime/strtotime.js","webpack://Twig/./node_modules/locutus/php/datetime/date.js","webpack://Twig/./node_modules/locutus/php/var/boolval.js","webpack://Twig/./src/twig.loader.ajax.js","webpack://Twig/./src/twig.loader.fs.js","webpack://Twig/./node_modules/process/browser.js","webpack://Twig/./src/twig.logic.js","webpack://Twig/./src/twig.parser.source.js","webpack://Twig/./src/twig.parser.twig.js","webpack://Twig/./src/twig.path.js","webpack://Twig/./src/twig.tests.js","webpack://Twig/./src/twig.async.js","webpack://Twig/./src/twig.exports.js"],"names":["root","factory","exports","module","define","amd","window","installedModules","__webpack_require__","moduleId","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","obj","_typeof","iterator","constructor","configurable","writable","arr","len","length","arr2","Array","regex","args","arguments","format","_pad","str","chr","leftJustify","padding","join","justify","prefix","minWidth","padChar","diff","slice","_formatBaseX","base","precision","toString","_formatString","customPadChar","doFormat","substring","argIndex","modifiers","specifier","number","method","textTransform","j","positiveNumberPrefix","charAt","isFinite","Error","indexOf","undefined","String","fromCharCode","toUpperCase","Math","round","abs","toLowerCase","replace","err","isNaN","ceil","floor","parseInt","normalizeArray","parts","allowAboveRoot","up","last","splice","unshift","filter","xs","f","res","push","resolve","resolvedPath","resolvedAbsolute","path","process","cwd","TypeError","split","normalize","isAbsolute","trailingSlash","substr","paths","index","relative","from","to","trim","start","end","fromParts","toParts","min","samePartsLength","outputParts","concat","sep","delimiter","dirname","code","charCodeAt","hasRoot","matchedSlash","basename","ext","extname","startDot","startPart","preDotState","require","Twig","VERSION","handleException","state","ex","template","options","rethrow","type","file","id","log","error","stack","debug","trace","cache","noop","merge","target","source","onlyChanged","keys","forEach","message","this","console","token","output","logic","comment","raw","outputWhitespacePre","outputWhitespacePost","outputWhitespaceBoth","logicWhitespacePre","logicWhitespacePost","logicWhitespaceBoth","definitions","open","close","strings","findStart","tokenTemplate","firstKeyPosition","closeKeyPosition","position","def","closePosition","findEnd","tokenDef","found","offset","strPos","strFound","pos","endOffset","thisStrPos","endStrPos","tokenize","tokens","errorOffset","foundToken","max","compile","self","intermediateOutput","logicToken","unclosedToken","prevToken","prevOutput","prevIntermediateOutput","nextToken","tokOutput","next","compileOutput","expression","compileLogic","handler","pop","includes","shift","trimEnd","trimStart","prepare","data","rawTokens","autoescape","strategy","escapedOutput","map","twigMarkup","filters","escape","joinedOutput","Markup","Templates","loaders","parsers","registry","validateId","registerLoader","methodName","func","scope","unRegisterLoader","isRegisteredLoader","registerParser","unRegisterParser","isRegisteredParser","save","load","loadRemote","location","params","callback","errorCallback","cached","parser","async","fs","Block","render","parseState","context","originalTemplate","parseAsync","then","string","ParseState","blockOverrides","renderedBlocks","overrideBlocks","macros","nestingStack","getBlock","checkOnlyInheritedBlocks","block","parentTemplate","getBlocks","includeParentBlocks","blocks","getNestingStackToken","matchingToken","parse","allowAsync","promise","isAsync","chain","outputPush","parseTokenLogic","Template","clas","url","defined","imported","checkImports","potentiallyAsync","allowInlineIncludes","parsePath","getLoaderMethod","renderAsync","isInclude","valueOf","importFile","subTemplate","compiler","content","JSON","stringify","twig","wrap","pathToTwig","node","cjs2","parseParams","Promise","reservedWords","comma","operator","unary","binary","bool","array","parameter","subexpression","period","brackets","_function","variable","_null","test","set","operations","expressions","operationsExtended","fn","pushBoth","pushValue","match","modifier","result","stackToken","Number","transform","lookup","associativity","leftToRight","precidence","rightToLeft","temp","keyToken","loop","validate","foundSubexpressionStart","nextSubexpressionStartInvalid","unclosedParameterCount","endToken","paramStack","lastToken","newArray","arrayEnded","sliceRange","sliceStart","sliceEnd","input","newObject","objectEnded","hasValue","_keys","functions","apply","resolveAsync","strictVariables","capitalize","parameters","cleanup","extendType","extend","definition","regexI","tokenNext","matchFound","expOffset","invalidMatches","matchFunction","matchI","isArray","rawToken","tokensAreParameters","loopTokenFixups","binaryOperator","loopTokenFixup","arrayWithoutHoles","iterableToArray","unsupportedIterableToArray","nonIterableSpread","arrayLikeToArray","iter","minLen","containment","a","b","el","reParts","reBody","reFlags","RegExp","lib","boolval","parseFloat","range","is","upper","lower","title","p1","p2","reverse","sort","sortedKeys","a1","b1","keyset","url_encode","serialize","resultKey","resultValue","encodeURIComponent","joinStr","json_encode","v","toISOString","arrIndex","param","val","intKey","date","Boolean","date_modify","time","modifyText","strtotime","getTime","Date","tag","pairs","replaceAll","vsprintf","striptags","allowed","stripTags","rawValue","char","charCode","shortMap","sprintf","e","nl2br","br","number_format","decimals","dec","prec","k","toFixedFix","whitespace","truncate","preserve","separator","startIndex","first","limit","limitedSplit","batch","items","missing","size","fill","chunkArray","spaceless","low","high","step","inival","endval","matrix","walker","chars","cycle","dump","argsCopy","EOL","indentChar","indentTimes","out","indent","times","ind","displayVar","dumpVar","dateObj","blockName","parent","attribute","values","Reflect","template_from_string","random","getRandomNumber","LIMIT_INT31","ignoreMissing","templateSource","templateFound","fetchTemplateSource","search","searchEscaped","returnVal","x","roundToInt","tmp","floatCast","intCast","pow","trunc","preRoundPrecision","log10","ar","retVal","argv","argc","_obj2Array","_compare","current","nl","cl","_phpCastString","tags","commentsAndPhpTags","after","before","$0","$1","reMeridian","reHour24","reHour24lz","reHour12","reMinute","reMinutelz","reSecond","reSecondlz","reDayfull","reDaytext","reReltextnumber","reReltextunit","reYear","reYear4","reMonth","reMonthlz","reDay","reDaylz","reMonthFull","reMonthAbbr","reMonthText","reTzCorrection","reDateNoYear","processMeridian","hour","meridian","processYear","yearStr","year","lookupMonth","monthStr","jan","january","feb","february","ii","mar","march","iii","apr","april","iv","may","jun","june","vi","jul","july","vii","aug","august","viii","sept","september","ix","oct","october","nov","november","xi","december","xii","lookupWeekday","dayStr","desiredSundayNumber","dayNumbers","mon","monday","tue","tuesday","wed","wednesday","thu","thursday","fri","friday","sat","saturday","sun","sunday","processTzCorrection","tzOffset","oldValue","sign","hours","minutes","formats","yesterday","rd","resetTime","now","noon","midnightOrToday","tomorrow","timestamp","rs","y","dates","zone","firstOrLastDay","day","firstOrLastDayOfMonth","backOrFrontOf","side","minute","weekdayOf","mssqltime","second","frac","timeLong12","timeShort12","timeTiny12","soap","month","tzCorrection","ymd","wddx","exif","xmlRpc","xmlRpcNoColon","clf","iso8601long","dateTextual","pointedDate4","pointedDate2","timeLong24","dateNoColon","pgydotd","timeShort24","iso8601noColon","iso8601dateSlash","dateSlash","american","americanShort","gnuDateShortOrIso8601date2","iso8601date4","gnuNoColon","gnuDateShorter","pgTextReverse","dateFull","dateNoDay","dateNoDayRev","pgTextShort","dateNoYear","dateNoYearRev","isoWeekDay","week","dayOfWeek","getDay","relativeText","relValue","relUnit","relTextLower","_lookupRelative","amount","previous","third","fourth","fifth","sixth","seventh","eight","eighth","ninth","tenth","eleventh","twelfth","behavior","ri","rh","rm","ry","weekday","weekdayBehavior","signs","minuses","dayText","relativeTextWeek","relText","monthFullOrMonthAbbr","ago","rf","year4","dateShortWithTimeLong","dateShortWithTimeLong12","dateShortWithTimeShort","dateShortWithTimeShort12","resultProto","NaN","h","z","zones","toDate","relativeTo","getFullYear","getMonth","getDate","getHours","getMinutes","getSeconds","getMilliseconds","setFullYear","setHours","dow","setDate","setMonth","getTimezoneOffset","setUTCFullYear","setUTCHours","rules","longestMatch","finalRule","jsdate","txtWords","formatChr","formatChrCb","D","w","N","S","Y","W","F","M","L","A","B","H","getUTCHours","getUTCMinutes","getUTCSeconds","g","G","u","I","UTC","O","tzo","P","T","Z","U","_date","mixedVar","precompiled","XMLHttpRequest","xmlhttp","onreadystatechange","readyState","status","cordova","responseText","overrideMimeType","send","warn","loadTemplateFn","stat","stats","isFile","readFile","statSync","readFileSync","cachedSetTimeout","cachedClearTimeout","defaultSetTimout","defaultClearTimeout","runTimeout","fun","setTimeout","clearTimeout","currentQueue","queue","draining","queueIndex","cleanUpNextTick","drainQueue","timeout","run","marker","runClearTimeout","Item","nextTick","browser","env","version","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","chdir","dir","umask","if_","endif","for_","endfor","else_","elseif","setcapture","endset","endfilter","endapply","do","shortblock","endblock","extends_","use","include","endspaceless","macro","endmacro","import_","embed","endembed","with","endwith","deprecated","keyValue","conditional","kvSplit","keyVar","valueVar","continueChain","innerContext","isConditional","index0","revindex","revindex0","buildLoop","condition","tokenOutput","expressionStack","fileName","reduce","acc","filePath","useTemplate","useState","withContext","only","withStack","lastError","macroName","rawParameters","rawParameter","parametersCount","uniq","defaults","pair","macroContext","_self","prop","contextName","importTemplate","importState","macroNames","macroMatch","embedContext","embedOverrideTemplate","tokenTemplateType","tokenType","tokenRegex","regexArray","regexLen","exec","isPromise","_file","namespaces","colon","atSign","namespacePath","relativePath","basePath","sepChr","newPath","tests","empty","odd","even","divisibleby","none","sameas","iterable","that","action","potentiallyAsyncSlow","Thenable","_value","_state","onRejected","resolvedThen","onResolved","reject","rejectedThen","executor","changeState","nextState","nextValue","FullPromise","handlers","resolved","rejected","append","pending","newState","hasResolved","hasRejected","defaultResolved","emptyStringResolved","all","promises","results","resp","strict_variables","ref","href","extendFilter","extendFunction","extendTest","extendTag","markup","filename","settings","renderFile","viewOptions","views","option","__express"],"mappings":"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","file":"twig.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[\"Twig\"] = factory();\n\telse\n\t\troot[\"Twig\"] = factory();\n})(window, function() {\nreturn "," \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, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\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\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 7);\n","function _interopRequireDefault(obj) {\n  return obj && obj.__esModule ? obj : {\n    \"default\": obj\n  };\n}\n\nmodule.exports = _interopRequireDefault;","function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n    module.exports = _typeof = function _typeof(obj) {\n      return typeof obj;\n    };\n  } else {\n    module.exports = _typeof = function _typeof(obj) {\n      return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n    };\n  }\n\n  return _typeof(obj);\n}\n\nmodule.exports = _typeof;","function _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nmodule.exports = _defineProperty;","function _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n\n  for (var i = 0, arr2 = new Array(len); i < len; i++) {\n    arr2[i] = arr[i];\n  }\n\n  return arr2;\n}\n\nmodule.exports = _arrayLikeToArray;","'use strict';\n\nmodule.exports = function sprintf() {\n  //  discuss at: https://locutus.io/php/sprintf/\n  // original by: Ash Searle (https://hexmen.com/blog/)\n  // improved by: Michael White (https://getsprink.com)\n  // improved by: Jack\n  // improved by: Kevin van Zonneveld (https://kvz.io)\n  // improved by: Kevin van Zonneveld (https://kvz.io)\n  // improved by: Kevin van Zonneveld (https://kvz.io)\n  // improved by: Dj\n  // improved by: Allidylls\n  //    input by: Paulo Freitas\n  //    input by: Brett Zamir (https://brett-zamir.me)\n  // improved by: Rafał Kukawski (https://kukawski.pl)\n  //   example 1: sprintf(\"%01.2f\", 123.1)\n  //   returns 1: '123.10'\n  //   example 2: sprintf(\"[%10s]\", 'monkey')\n  //   returns 2: '[    monkey]'\n  //   example 3: sprintf(\"[%'#10s]\", 'monkey')\n  //   returns 3: '[####monkey]'\n  //   example 4: sprintf(\"%d\", 123456789012345)\n  //   returns 4: '123456789012345'\n  //   example 5: sprintf('%-03s', 'E')\n  //   returns 5: 'E00'\n  //   example 6: sprintf('%+010d', 9)\n  //   returns 6: '+000000009'\n  //   example 7: sprintf('%+0\\'@10d', 9)\n  //   returns 7: '@@@@@@@@+9'\n  //   example 8: sprintf('%.f', 3.14)\n  //   returns 8: '3.140000'\n  //   example 9: sprintf('%% %2$d', 1, 2)\n  //   returns 9: '% 2'\n\n  var regex = /%%|%(?:(\\d+)\\$)?((?:[-+#0 ]|'[\\s\\S])*)(\\d+)?(?:\\.(\\d*))?([\\s\\S])/g;\n  var args = arguments;\n  var i = 0;\n  var format = args[i++];\n\n  var _pad = function _pad(str, len, chr, leftJustify) {\n    if (!chr) {\n      chr = ' ';\n    }\n    var padding = str.length >= len ? '' : new Array(1 + len - str.length >>> 0).join(chr);\n    return leftJustify ? str + padding : padding + str;\n  };\n\n  var justify = function justify(value, prefix, leftJustify, minWidth, padChar) {\n    var diff = minWidth - value.length;\n    if (diff > 0) {\n      // when padding with zeros\n      // on the left side\n      // keep sign (+ or -) in front\n      if (!leftJustify && padChar === '0') {\n        value = [value.slice(0, prefix.length), _pad('', diff, '0', true), value.slice(prefix.length)].join('');\n      } else {\n        value = _pad(value, minWidth, padChar, leftJustify);\n      }\n    }\n    return value;\n  };\n\n  var _formatBaseX = function _formatBaseX(value, base, leftJustify, minWidth, precision, padChar) {\n    // Note: casts negative numbers to positive ones\n    var number = value >>> 0;\n    value = _pad(number.toString(base), precision || 0, '0', false);\n    return justify(value, '', leftJustify, minWidth, padChar);\n  };\n\n  // _formatString()\n  var _formatString = function _formatString(value, leftJustify, minWidth, precision, customPadChar) {\n    if (precision !== null && precision !== undefined) {\n      value = value.slice(0, precision);\n    }\n    return justify(value, '', leftJustify, minWidth, customPadChar);\n  };\n\n  // doFormat()\n  var doFormat = function doFormat(substring, argIndex, modifiers, minWidth, precision, specifier) {\n    var number, prefix, method, textTransform, value;\n\n    if (substring === '%%') {\n      return '%';\n    }\n\n    // parse modifiers\n    var padChar = ' '; // pad with spaces by default\n    var leftJustify = false;\n    var positiveNumberPrefix = '';\n    var j, l;\n\n    for (j = 0, l = modifiers.length; j < l; j++) {\n      switch (modifiers.charAt(j)) {\n        case ' ':\n        case '0':\n          padChar = modifiers.charAt(j);\n          break;\n        case '+':\n          positiveNumberPrefix = '+';\n          break;\n        case '-':\n          leftJustify = true;\n          break;\n        case \"'\":\n          if (j + 1 < l) {\n            padChar = modifiers.charAt(j + 1);\n            j++;\n          }\n          break;\n      }\n    }\n\n    if (!minWidth) {\n      minWidth = 0;\n    } else {\n      minWidth = +minWidth;\n    }\n\n    if (!isFinite(minWidth)) {\n      throw new Error('Width must be finite');\n    }\n\n    if (!precision) {\n      precision = specifier === 'd' ? 0 : 'fFeE'.indexOf(specifier) > -1 ? 6 : undefined;\n    } else {\n      precision = +precision;\n    }\n\n    if (argIndex && +argIndex === 0) {\n      throw new Error('Argument number must be greater than zero');\n    }\n\n    if (argIndex && +argIndex >= args.length) {\n      throw new Error('Too few arguments');\n    }\n\n    value = argIndex ? args[+argIndex] : args[i++];\n\n    switch (specifier) {\n      case '%':\n        return '%';\n      case 's':\n        return _formatString(value + '', leftJustify, minWidth, precision, padChar);\n      case 'c':\n        return _formatString(String.fromCharCode(+value), leftJustify, minWidth, precision, padChar);\n      case 'b':\n        return _formatBaseX(value, 2, leftJustify, minWidth, precision, padChar);\n      case 'o':\n        return _formatBaseX(value, 8, leftJustify, minWidth, precision, padChar);\n      case 'x':\n        return _formatBaseX(value, 16, leftJustify, minWidth, precision, padChar);\n      case 'X':\n        return _formatBaseX(value, 16, leftJustify, minWidth, precision, padChar).toUpperCase();\n      case 'u':\n        return _formatBaseX(value, 10, leftJustify, minWidth, precision, padChar);\n      case 'i':\n      case 'd':\n        number = +value || 0;\n        // Plain Math.round doesn't just truncate\n        number = Math.round(number - number % 1);\n        prefix = number < 0 ? '-' : positiveNumberPrefix;\n        value = prefix + _pad(String(Math.abs(number)), precision, '0', false);\n\n        if (leftJustify && padChar === '0') {\n          // can't right-pad 0s on integers\n          padChar = ' ';\n        }\n        return justify(value, prefix, leftJustify, minWidth, padChar);\n      case 'e':\n      case 'E':\n      case 'f': // @todo: Should handle locales (as per setlocale)\n      case 'F':\n      case 'g':\n      case 'G':\n        number = +value;\n        prefix = number < 0 ? '-' : positiveNumberPrefix;\n        method = ['toExponential', 'toFixed', 'toPrecision']['efg'.indexOf(specifier.toLowerCase())];\n        textTransform = ['toString', 'toUpperCase']['eEfFgG'.indexOf(specifier) % 2];\n        value = prefix + Math.abs(number)[method](precision);\n        return justify(value, prefix, leftJustify, minWidth, padChar)[textTransform]();\n      default:\n        // unknown specifier, consume that char and return empty\n        return '';\n    }\n  };\n\n  try {\n    return format.replace(regex, doFormat);\n  } catch (err) {\n    return false;\n  }\n};\n//# sourceMappingURL=sprintf.js.map","'use strict';\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nmodule.exports = function _php_cast_int(value) {\n  // eslint-disable-line camelcase\n  // original by: Rafał Kukawski\n  //   example 1: _php_cast_int(false)\n  //   returns 1: 0\n  //   example 2: _php_cast_int(true)\n  //   returns 2: 1\n  //   example 3: _php_cast_int(0)\n  //   returns 3: 0\n  //   example 4: _php_cast_int(1)\n  //   returns 4: 1\n  //   example 5: _php_cast_int(3.14)\n  //   returns 5: 3\n  //   example 6: _php_cast_int('')\n  //   returns 6: 0\n  //   example 7: _php_cast_int('0')\n  //   returns 7: 0\n  //   example 8: _php_cast_int('abc')\n  //   returns 8: 0\n  //   example 9: _php_cast_int(null)\n  //   returns 9: 0\n  //  example 10: _php_cast_int(undefined)\n  //  returns 10: 0\n  //  example 11: _php_cast_int('123abc')\n  //  returns 11: 123\n  //  example 12: _php_cast_int('123e4')\n  //  returns 12: 123\n  //  example 13: _php_cast_int(0x200000001)\n  //  returns 13: 8589934593\n\n  var type = typeof value === 'undefined' ? 'undefined' : _typeof(value);\n\n  switch (type) {\n    case 'number':\n      if (isNaN(value) || !isFinite(value)) {\n        // from PHP 7, NaN and Infinity are casted to 0\n        return 0;\n      }\n\n      return value < 0 ? Math.ceil(value) : Math.floor(value);\n    case 'string':\n      return parseInt(value, 10) || 0;\n    case 'boolean':\n    // fall through\n    default:\n      // Behaviour for types other than float, string, boolean\n      // is undefined and can change any time.\n      // To not invent complex logic\n      // that mimics PHP 7.0 behaviour\n      // casting value->bool->number is used\n      return +!!value;\n  }\n};\n//# sourceMappingURL=_php_cast_int.js.map","// .dirname, .basename, and .extname methods are extracted from Node.js v8.11.1,\n// backported and transplited with Babel, with backwards-compat fixes\n\n// 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// resolves . and .. elements in a path array with directory names there\n// must be no slashes, empty elements, or device names (c:\\) in the array\n// (so also no leading and trailing slashes - it does not distinguish\n// relative and absolute paths)\nfunction normalizeArray(parts, allowAboveRoot) {\n  // if the path tries to go above the root, `up` ends up > 0\n  var up = 0;\n  for (var i = parts.length - 1; i >= 0; i--) {\n    var last = parts[i];\n    if (last === '.') {\n      parts.splice(i, 1);\n    } else if (last === '..') {\n      parts.splice(i, 1);\n      up++;\n    } else if (up) {\n      parts.splice(i, 1);\n      up--;\n    }\n  }\n\n  // if the path is allowed to go above the root, restore leading ..s\n  if (allowAboveRoot) {\n    for (; up--; up) {\n      parts.unshift('..');\n    }\n  }\n\n  return parts;\n}\n\n// path.resolve([from ...], to)\n// posix version\nexports.resolve = function() {\n  var resolvedPath = '',\n      resolvedAbsolute = false;\n\n  for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n    var path = (i >= 0) ? arguments[i] : process.cwd();\n\n    // Skip empty and invalid entries\n    if (typeof path !== 'string') {\n      throw new TypeError('Arguments to path.resolve must be strings');\n    } else if (!path) {\n      continue;\n    }\n\n    resolvedPath = path + '/' + resolvedPath;\n    resolvedAbsolute = path.charAt(0) === '/';\n  }\n\n  // At this point the path should be resolved to a full absolute path, but\n  // handle relative paths to be safe (might happen when process.cwd() fails)\n\n  // Normalize the path\n  resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {\n    return !!p;\n  }), !resolvedAbsolute).join('/');\n\n  return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';\n};\n\n// path.normalize(path)\n// posix version\nexports.normalize = function(path) {\n  var isAbsolute = exports.isAbsolute(path),\n      trailingSlash = substr(path, -1) === '/';\n\n  // Normalize the path\n  path = normalizeArray(filter(path.split('/'), function(p) {\n    return !!p;\n  }), !isAbsolute).join('/');\n\n  if (!path && !isAbsolute) {\n    path = '.';\n  }\n  if (path && trailingSlash) {\n    path += '/';\n  }\n\n  return (isAbsolute ? '/' : '') + path;\n};\n\n// posix version\nexports.isAbsolute = function(path) {\n  return path.charAt(0) === '/';\n};\n\n// posix version\nexports.join = function() {\n  var paths = Array.prototype.slice.call(arguments, 0);\n  return exports.normalize(filter(paths, function(p, index) {\n    if (typeof p !== 'string') {\n      throw new TypeError('Arguments to path.join must be strings');\n    }\n    return p;\n  }).join('/'));\n};\n\n\n// path.relative(from, to)\n// posix version\nexports.relative = function(from, to) {\n  from = exports.resolve(from).substr(1);\n  to = exports.resolve(to).substr(1);\n\n  function trim(arr) {\n    var start = 0;\n    for (; start < arr.length; start++) {\n      if (arr[start] !== '') break;\n    }\n\n    var end = arr.length - 1;\n    for (; end >= 0; end--) {\n      if (arr[end] !== '') break;\n    }\n\n    if (start > end) return [];\n    return arr.slice(start, end - start + 1);\n  }\n\n  var fromParts = trim(from.split('/'));\n  var toParts = trim(to.split('/'));\n\n  var length = Math.min(fromParts.length, toParts.length);\n  var samePartsLength = length;\n  for (var i = 0; i < length; i++) {\n    if (fromParts[i] !== toParts[i]) {\n      samePartsLength = i;\n      break;\n    }\n  }\n\n  var outputParts = [];\n  for (var i = samePartsLength; i < fromParts.length; i++) {\n    outputParts.push('..');\n  }\n\n  outputParts = outputParts.concat(toParts.slice(samePartsLength));\n\n  return outputParts.join('/');\n};\n\nexports.sep = '/';\nexports.delimiter = ':';\n\nexports.dirname = function (path) {\n  if (typeof path !== 'string') path = path + '';\n  if (path.length === 0) return '.';\n  var code = path.charCodeAt(0);\n  var hasRoot = code === 47 /*/*/;\n  var end = -1;\n  var matchedSlash = true;\n  for (var i = path.length - 1; i >= 1; --i) {\n    code = path.charCodeAt(i);\n    if (code === 47 /*/*/) {\n        if (!matchedSlash) {\n          end = i;\n          break;\n        }\n      } else {\n      // We saw the first non-path separator\n      matchedSlash = false;\n    }\n  }\n\n  if (end === -1) return hasRoot ? '/' : '.';\n  if (hasRoot && end === 1) {\n    // return '//';\n    // Backwards-compat fix:\n    return '/';\n  }\n  return path.slice(0, end);\n};\n\nfunction basename(path) {\n  if (typeof path !== 'string') path = path + '';\n\n  var start = 0;\n  var end = -1;\n  var matchedSlash = true;\n  var i;\n\n  for (i = path.length - 1; i >= 0; --i) {\n    if (path.charCodeAt(i) === 47 /*/*/) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          start = i + 1;\n          break;\n        }\n      } else if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // path component\n      matchedSlash = false;\n      end = i + 1;\n    }\n  }\n\n  if (end === -1) return '';\n  return path.slice(start, end);\n}\n\n// Uses a mixed approach for backwards-compatibility, as ext behavior changed\n// in new Node.js versions, so only basename() above is backported here\nexports.basename = function (path, ext) {\n  var f = basename(path);\n  if (ext && f.substr(-1 * ext.length) === ext) {\n    f = f.substr(0, f.length - ext.length);\n  }\n  return f;\n};\n\nexports.extname = function (path) {\n  if (typeof path !== 'string') path = path + '';\n  var startDot = -1;\n  var startPart = 0;\n  var end = -1;\n  var matchedSlash = true;\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find\n  var preDotState = 0;\n  for (var i = path.length - 1; i >= 0; --i) {\n    var code = path.charCodeAt(i);\n    if (code === 47 /*/*/) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          startPart = i + 1;\n          break;\n        }\n        continue;\n      }\n    if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension\n      matchedSlash = false;\n      end = i + 1;\n    }\n    if (code === 46 /*.*/) {\n        // If this is our first dot, mark it as the start of our extension\n        if (startDot === -1)\n          startDot = i;\n        else if (preDotState !== 1)\n          preDotState = 1;\n    } else if (startDot !== -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension\n      preDotState = -1;\n    }\n  }\n\n  if (startDot === -1 || end === -1 ||\n      // We saw a non-dot character immediately before the dot\n      preDotState === 0 ||\n      // The (right-most) trimmed path component is exactly '..'\n      preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n    return '';\n  }\n  return path.slice(startDot, end);\n};\n\nfunction filter (xs, f) {\n    if (xs.filter) return xs.filter(f);\n    var res = [];\n    for (var i = 0; i < xs.length; i++) {\n        if (f(xs[i], i, xs)) res.push(xs[i]);\n    }\n    return res;\n}\n\n// String.prototype.substr - negative index don't work in IE8\nvar substr = 'ab'.substr(-1) === 'b'\n    ? function (str, start, len) { return str.substr(start, len) }\n    : function (str, start, len) {\n        if (start < 0) start = str.length + start;\n        return str.substr(start, len);\n    }\n;\n","/**\n * Twig.js\n *\n * @copyright 2011-2020 John Roepke and the Twig.js Contributors\n * @license   Available under the BSD 2-Clause License\n * @link      https://github.com/twigjs/twig.js\n */\n\nmodule.exports = require('./twig.factory')();\n","// ## twig.factory.js\n//\n// This file handles creating the Twig library\nmodule.exports = function factory() {\n    const Twig = {\n        VERSION: '1.14.0'\n    };\n\n    require('./twig.core')(Twig);\n    require('./twig.compiler')(Twig);\n    require('./twig.expression')(Twig);\n    require('./twig.filters')(Twig);\n    require('./twig.functions')(Twig);\n    require('./twig.lib')(Twig);\n    require('./twig.loader.ajax')(Twig);\n    require('./twig.loader.fs')(Twig);\n    require('./twig.logic')(Twig);\n    require('./twig.parser.source')(Twig);\n    require('./twig.parser.twig')(Twig);\n    require('./twig.path')(Twig);\n    require('./twig.tests')(Twig);\n    require('./twig.async')(Twig);\n    require('./twig.exports')(Twig);\n\n    Twig.exports.factory = factory;\n\n    return Twig.exports;\n};\n","// ## twig.core.js\n//\n// This file handles template level tokenizing, compiling and parsing.\nmodule.exports = function (Twig) {\n    'use strict';\n\n    Twig.trace = false;\n    Twig.debug = false;\n\n    // Default caching to true for the improved performance it offers\n    Twig.cache = true;\n\n    Twig.noop = function () {};\n\n    Twig.merge = function (target, source, onlyChanged) {\n        Object.keys(source).forEach(key => {\n            if (onlyChanged && !(key in target)) {\n                return;\n            }\n\n            target[key] = source[key];\n        });\n\n        return target;\n    };\n\n    /**\n     * Exception thrown by twig.js.\n     */\n    Twig.Error = function (message, file) {\n        this.message = message;\n        this.name = 'TwigException';\n        this.type = 'TwigException';\n        this.file = file;\n    };\n\n    /**\n     * Get the string representation of a Twig error.\n     */\n    Twig.Error.prototype.toString = function () {\n        const output = this.name + ': ' + this.message;\n\n        return output;\n    };\n\n    /**\n     * Wrapper for logging to the console.\n     */\n    Twig.log = {\n        trace(...args) {\n            if (Twig.trace && console) {\n                console.log(Array.prototype.slice.call(args));\n            }\n        },\n        debug(...args) {\n            if (Twig.debug && console) {\n                console.log(Array.prototype.slice.call(args));\n            }\n        }\n    };\n\n    if (typeof console === 'undefined') {\n        Twig.log.error = function () {};\n    } else if (typeof console.error !== 'undefined') {\n        Twig.log.error = function (...args) {\n            console.error(...args);\n        };\n    } else if (typeof console.log !== 'undefined') {\n        Twig.log.error = function (...args) {\n            console.log(...args);\n        };\n    }\n\n    /**\n     * Container for methods related to handling high level template tokens\n     *      (for example: {{ expression }}, {% logic %}, {# comment #}, raw data)\n     */\n    Twig.token = {};\n\n    /**\n     * Token types.\n     */\n    Twig.token.type = {\n        output: 'output',\n        logic: 'logic',\n        comment: 'comment',\n        raw: 'raw',\n        outputWhitespacePre: 'output_whitespace_pre',\n        outputWhitespacePost: 'output_whitespace_post',\n        outputWhitespaceBoth: 'output_whitespace_both',\n        logicWhitespacePre: 'logic_whitespace_pre',\n        logicWhitespacePost: 'logic_whitespace_post',\n        logicWhitespaceBoth: 'logic_whitespace_both'\n    };\n\n    /**\n     * Token syntax definitions.\n     */\n    Twig.token.definitions = [\n        {\n            type: Twig.token.type.raw,\n            open: '{% raw %}',\n            close: '{% endraw %}'\n        },\n        {\n            type: Twig.token.type.raw,\n            open: '{% verbatim %}',\n            close: '{% endverbatim %}'\n        },\n        // *Whitespace type tokens*\n        //\n        // These typically take the form `{{- expression -}}` or `{{- expression }}` or `{{ expression -}}`.\n        {\n            type: Twig.token.type.outputWhitespacePre,\n            open: '{{-',\n            close: '}}'\n        },\n        {\n            type: Twig.token.type.outputWhitespacePost,\n            open: '{{',\n            close: '-}}'\n        },\n        {\n            type: Twig.token.type.outputWhitespaceBoth,\n            open: '{{-',\n            close: '-}}'\n        },\n        {\n            type: Twig.token.type.logicWhitespacePre,\n            open: '{%-',\n            close: '%}'\n        },\n        {\n            type: Twig.token.type.logicWhitespacePost,\n            open: '{%',\n            close: '-%}'\n        },\n        {\n            type: Twig.token.type.logicWhitespaceBoth,\n            open: '{%-',\n            close: '-%}'\n        },\n        // *Output type tokens*\n        //\n        // These typically take the form `{{ expression }}`.\n        {\n            type: Twig.token.type.output,\n            open: '{{',\n            close: '}}'\n        },\n        // *Logic type tokens*\n        //\n        // These typically take a form like `{% if expression %}` or `{% endif %}`\n        {\n            type: Twig.token.type.logic,\n            open: '{%',\n            close: '%}'\n        },\n        // *Comment type tokens*\n        //\n        // These take the form `{# anything #}`\n        {\n            type: Twig.token.type.comment,\n            open: '{#',\n            close: '#}'\n        }\n    ];\n\n    /**\n     * What characters start \"strings\" in token definitions. We need this to ignore token close\n     * strings inside an expression.\n     */\n    Twig.token.strings = ['\"', '\\''];\n\n    Twig.token.findStart = function (template) {\n        const output = {\n            position: null,\n            def: null\n        };\n        let closePosition = null;\n        const len = Twig.token.definitions.length;\n        let i;\n        let tokenTemplate;\n        let firstKeyPosition;\n        let closeKeyPosition;\n\n        for (i = 0; i < len; i++) {\n            tokenTemplate = Twig.token.definitions[i];\n            firstKeyPosition = template.indexOf(tokenTemplate.open);\n            closeKeyPosition = template.indexOf(tokenTemplate.close);\n\n            Twig.log.trace('Twig.token.findStart: ', 'Searching for ', tokenTemplate.open, ' found at ', firstKeyPosition);\n\n            // Special handling for mismatched tokens\n            if (firstKeyPosition >= 0) {\n                // This token matches the template\n                if (tokenTemplate.open.length !== tokenTemplate.close.length) {\n                    // This token has mismatched closing and opening tags\n                    if (closeKeyPosition < 0) {\n                        // This token's closing tag does not match the template\n                        continue;\n                    }\n                }\n            }\n            // Does this token occur before any other types?\n\n            if (firstKeyPosition >= 0 && (output.position === null || firstKeyPosition < output.position)) {\n                output.position = firstKeyPosition;\n                output.def = tokenTemplate;\n                closePosition = closeKeyPosition;\n            } else if (firstKeyPosition >= 0 && output.position !== null && firstKeyPosition === output.position) {\n                /* This token exactly matches another token,\n                greedily match to check if this token has a greater specificity */\n                if (tokenTemplate.open.length > output.def.open.length) {\n                    // This token's opening tag is more specific than the previous match\n                    output.position = firstKeyPosition;\n                    output.def = tokenTemplate;\n                    closePosition = closeKeyPosition;\n                } else if (tokenTemplate.open.length === output.def.open.length) {\n                    if (tokenTemplate.close.length > output.def.close.length) {\n                        // This token's opening tag is as specific as the previous match,\n                        // but the closing tag has greater specificity\n                        if (closeKeyPosition >= 0 && closeKeyPosition < closePosition) {\n                            // This token's closing tag exists in the template,\n                            // and it occurs sooner than the previous match\n                            output.position = firstKeyPosition;\n                            output.def = tokenTemplate;\n                            closePosition = closeKeyPosition;\n                        }\n                    } else if (closeKeyPosition >= 0 && closeKeyPosition < closePosition) {\n                        // This token's closing tag is not more specific than the previous match,\n                        // but it occurs sooner than the previous match\n                        output.position = firstKeyPosition;\n                        output.def = tokenTemplate;\n                        closePosition = closeKeyPosition;\n                    }\n                }\n            }\n        }\n\n        return output;\n    };\n\n    Twig.token.findEnd = function (template, tokenDef, start) {\n        let end = null;\n        let found = false;\n        let offset = 0;\n\n        // String position variables\n        let strPos = null;\n        let strFound = null;\n        let pos = null;\n        let endOffset = null;\n        let thisStrPos = null;\n        let endStrPos = null;\n\n        // For loop variables\n        let i;\n        let l;\n\n        while (!found) {\n            strPos = null;\n            strFound = null;\n            pos = template.indexOf(tokenDef.close, offset);\n\n            if (pos >= 0) {\n                end = pos;\n                found = true;\n            } else {\n                // Throw an exception\n                throw new Twig.Error('Unable to find closing bracket \\'' + tokenDef.close +\n                                '\\' opened near template position ' + start);\n            }\n\n            // Ignore quotes within comments; just look for the next comment close sequence,\n            // regardless of what comes before it. https://github.com/justjohn/twig.js/issues/95\n            if (tokenDef.type === Twig.token.type.comment) {\n                break;\n            }\n            // Ignore quotes within raw tag\n            // Fixes #283\n\n            if (tokenDef.type === Twig.token.type.raw) {\n                break;\n            }\n\n            l = Twig.token.strings.length;\n            for (i = 0; i < l; i += 1) {\n                thisStrPos = template.indexOf(Twig.token.strings[i], offset);\n\n                if (thisStrPos > 0 && thisStrPos < pos &&\n                        (strPos === null || thisStrPos < strPos)) {\n                    strPos = thisStrPos;\n                    strFound = Twig.token.strings[i];\n                }\n            }\n\n            // We found a string before the end of the token, now find the string's end and set the search offset to it\n            if (strPos !== null) {\n                endOffset = strPos + 1;\n                end = null;\n                found = false;\n                for (;;) {\n                    endStrPos = template.indexOf(strFound, endOffset);\n                    if (endStrPos < 0) {\n                        throw Twig.Error('Unclosed string in template');\n                    }\n                    // Ignore escaped quotes\n\n                    if (template.slice(endStrPos - 1, endStrPos) === '\\\\') {\n                        endOffset = endStrPos + 1;\n                    } else {\n                        offset = endStrPos + 1;\n                        break;\n                    }\n                }\n            }\n        }\n\n        return end;\n    };\n\n    /**\n     * Convert a template into high-level tokens.\n     */\n    Twig.tokenize = function (template) {\n        const tokens = [];\n        // An offset for reporting errors locations in the template.\n        let errorOffset = 0;\n\n        // The start and type of the first token found in the template.\n        let foundToken = null;\n        // The end position of the matched token.\n        let end = null;\n\n        while (template.length > 0) {\n            // Find the first occurance of any token type in the template\n            foundToken = Twig.token.findStart(template);\n\n            Twig.log.trace('Twig.tokenize: ', 'Found token: ', foundToken);\n\n            if (foundToken.position === null) {\n                // No more tokens -> add the rest of the template as a raw-type token\n                tokens.push({\n                    type: Twig.token.type.raw,\n                    value: template\n                });\n                template = '';\n            } else {\n                // Add a raw type token for anything before the start of the token\n                if (foundToken.position > 0) {\n                    tokens.push({\n                        type: Twig.token.type.raw,\n                        value: template.slice(0, Math.max(0, foundToken.position))\n                    });\n                }\n\n                template = template.slice(foundToken.position + foundToken.def.open.length);\n                errorOffset += foundToken.position + foundToken.def.open.length;\n\n                // Find the end of the token\n                end = Twig.token.findEnd(template, foundToken.def, errorOffset);\n\n                Twig.log.trace('Twig.tokenize: ', 'Token ends at ', end);\n\n                tokens.push({\n                    type: foundToken.def.type,\n                    value: template.slice(0, Math.max(0, end)).trim()\n                });\n\n                if (template.slice(end + foundToken.def.close.length, end + foundToken.def.close.length + 1) === '\\n') {\n                    switch (foundToken.def.type) {\n                        case 'logic_whitespace_pre':\n                        case 'logic_whitespace_post':\n                        case 'logic_whitespace_both':\n                        case 'logic':\n                            // Newlines directly after logic tokens are ignored\n                            end += 1;\n                            break;\n                        default:\n                            break;\n                    }\n                }\n\n                template = template.slice(end + foundToken.def.close.length);\n\n                // Increment the position in the template\n                errorOffset += end + foundToken.def.close.length;\n            }\n        }\n\n        return tokens;\n    };\n\n    Twig.compile = function (tokens) {\n        const self = this;\n        try {\n            // Output and intermediate stacks\n            const output = [];\n            const stack = [];\n            // The tokens between open and close tags\n            let intermediateOutput = [];\n\n            let token = null;\n            let logicToken = null;\n            let unclosedToken = null;\n            // Temporary previous token.\n            let prevToken = null;\n            // Temporary previous output.\n            let prevOutput = null;\n            // Temporary previous intermediate output.\n            let prevIntermediateOutput = null;\n            // The previous token's template\n            let prevTemplate = null;\n            // Token lookahead\n            let nextToken = null;\n            // The output token\n            let tokOutput = null;\n\n            // Logic Token values\n            let type = null;\n            let open = null;\n            let next = null;\n\n            const compileOutput = function (token) {\n                Twig.expression.compile.call(self, token);\n                if (stack.length > 0) {\n                    intermediateOutput.push(token);\n                } else {\n                    output.push(token);\n                }\n            };\n\n            const compileLogic = function (token) {\n                // Compile the logic token\n                logicToken = Twig.logic.compile.call(self, token);\n\n                type = logicToken.type;\n                open = Twig.logic.handler[type].open;\n                next = Twig.logic.handler[type].next;\n\n                Twig.log.trace('Twig.compile: ', 'Compiled logic token to ', logicToken,\n                    ' next is: ', next, ' open is : ', open);\n\n                // Not a standalone token, check logic stack to see if this is expected\n                if (open !== undefined && !open) {\n                    prevToken = stack.pop();\n                    prevTemplate = Twig.logic.handler[prevToken.type];\n\n                    if (!prevTemplate.next.includes(type)) {\n                        throw new Error(type + ' not expected after a ' + prevToken.type);\n                    }\n\n                    prevToken.output = prevToken.output || [];\n\n                    prevToken.output = prevToken.output.concat(intermediateOutput);\n                    intermediateOutput = [];\n\n                    tokOutput = {\n                        type: Twig.token.type.logic,\n                        token: prevToken\n                    };\n                    if (stack.length > 0) {\n                        intermediateOutput.push(tokOutput);\n                    } else {\n                        output.push(tokOutput);\n                    }\n                }\n\n                // This token requires additional tokens to complete the logic structure.\n                if (next !== undefined && next.length > 0) {\n                    Twig.log.trace('Twig.compile: ', 'Pushing ', logicToken, ' to logic stack.');\n\n                    if (stack.length > 0) {\n                        // Put any currently held output into the output list of the logic operator\n                        // currently at the head of the stack before we push a new one on.\n                        prevToken = stack.pop();\n                        prevToken.output = prevToken.output || [];\n                        prevToken.output = prevToken.output.concat(intermediateOutput);\n                        stack.push(prevToken);\n                        intermediateOutput = [];\n                    }\n\n                    // Push the new logic token onto the logic stack\n                    stack.push(logicToken);\n                } else if (open !== undefined && open) {\n                    tokOutput = {\n                        type: Twig.token.type.logic,\n                        token: logicToken\n                    };\n                    // Standalone token (like {% set ... %}\n                    if (stack.length > 0) {\n                        intermediateOutput.push(tokOutput);\n                    } else {\n                        output.push(tokOutput);\n                    }\n                }\n            };\n\n            while (tokens.length > 0) {\n                token = tokens.shift();\n                prevOutput = output[output.length - 1];\n                prevIntermediateOutput = intermediateOutput[intermediateOutput.length - 1];\n                nextToken = tokens[0];\n                Twig.log.trace('Compiling token ', token);\n                switch (token.type) {\n                    case Twig.token.type.raw:\n                        if (stack.length > 0) {\n                            intermediateOutput.push(token);\n                        } else {\n                            output.push(token);\n                        }\n\n                        break;\n\n                    case Twig.token.type.logic:\n                        compileLogic.call(self, token);\n                        break;\n\n                    // Do nothing, comments should be ignored\n                    case Twig.token.type.comment:\n                        break;\n\n                    case Twig.token.type.output:\n                        compileOutput.call(self, token);\n                        break;\n\n                    // Kill whitespace ahead and behind this token\n                    case Twig.token.type.logicWhitespacePre:\n                    case Twig.token.type.logicWhitespacePost:\n                    case Twig.token.type.logicWhitespaceBoth:\n                    case Twig.token.type.outputWhitespacePre:\n                    case Twig.token.type.outputWhitespacePost:\n                    case Twig.token.type.outputWhitespaceBoth:\n                        if (token.type !== Twig.token.type.outputWhitespacePost && token.type !== Twig.token.type.logicWhitespacePost) {\n                            if (prevOutput) {\n                                // If the previous output is raw, pop it off\n                                if (prevOutput.type === Twig.token.type.raw) {\n                                    output.pop();\n\n                                    prevOutput.value = prevOutput.value.trimEnd();\n                                    // Repush the previous output\n                                    output.push(prevOutput);\n                                }\n                            }\n\n                            if (prevIntermediateOutput) {\n                                // If the previous intermediate output is raw, pop it off\n                                if (prevIntermediateOutput.type === Twig.token.type.raw) {\n                                    intermediateOutput.pop();\n\n                                    prevIntermediateOutput.value = prevIntermediateOutput.value.trimEnd();\n                                    // Repush the previous intermediate output\n                                    intermediateOutput.push(prevIntermediateOutput);\n                                }\n                            }\n                        }\n\n                        // Compile this token\n                        switch (token.type) {\n                            case Twig.token.type.outputWhitespacePre:\n                            case Twig.token.type.outputWhitespacePost:\n                            case Twig.token.type.outputWhitespaceBoth:\n                                compileOutput.call(self, token);\n                                break;\n                            case Twig.token.type.logicWhitespacePre:\n                            case Twig.token.type.logicWhitespacePost:\n                            case Twig.token.type.logicWhitespaceBoth:\n                                compileLogic.call(self, token);\n                                break;\n                            default:\n                                break;\n                        }\n\n                        if (token.type !== Twig.token.type.outputWhitespacePre && token.type !== Twig.token.type.logicWhitespacePre) {\n                            if (nextToken) {\n                                // If the next token is raw, shift it out\n                                if (nextToken.type === Twig.token.type.raw) {\n                                    tokens.shift();\n\n                                    nextToken.value = nextToken.value.trimStart();\n                                    // Unshift the next token\n                                    tokens.unshift(nextToken);\n                                }\n                            }\n                        }\n\n                        break;\n                    default:\n                        break;\n                }\n\n                Twig.log.trace('Twig.compile: ', ' Output: ', output,\n                    ' Logic Stack: ', stack,\n                    ' Pending Output: ', intermediateOutput\n                );\n            }\n\n            // Verify that there are no logic tokens left in the stack.\n            if (stack.length > 0) {\n                unclosedToken = stack.pop();\n                throw new Error('Unable to find an end tag for ' + unclosedToken.type +\n                                ', expecting one of ' + unclosedToken.next);\n            }\n\n            return output;\n        } catch (error) {\n            if (self.options.rethrow) {\n                if (error.type === 'TwigException' && !error.file) {\n                    error.file = self.id;\n                }\n\n                throw error;\n            } else {\n                Twig.log.error('Error compiling twig template ' + self.id + ': ');\n                if (error.stack) {\n                    Twig.log.error(error.stack);\n                } else {\n                    Twig.log.error(error.toString());\n                }\n            }\n        }\n    };\n\n    function handleException(state, ex) {\n        if (state.template.options.rethrow) {\n            if (typeof ex === 'string') {\n                ex = new Twig.Error(ex);\n            }\n\n            if (ex.type === 'TwigException' && !ex.file) {\n                ex.file = state.template.id;\n            }\n\n            throw ex;\n        } else {\n            Twig.log.error('Error parsing twig template ' + state.template.id + ': ');\n            if (ex.stack) {\n                Twig.log.error(ex.stack);\n            } else {\n                Twig.log.error(ex.toString());\n            }\n\n            if (Twig.debug) {\n                return ex.toString();\n            }\n        }\n    }\n\n    /**\n     * Tokenize and compile a string template.\n     *\n     * @param {string} data The template.\n     *\n     * @return {Array} The compiled tokens.\n     */\n    Twig.prepare = function (data) {\n        // Tokenize\n        Twig.log.debug('Twig.prepare: ', 'Tokenizing ', data);\n        const rawTokens = Twig.tokenize.call(this, data);\n\n        // Compile\n        Twig.log.debug('Twig.prepare: ', 'Compiling ', rawTokens);\n        const tokens = Twig.compile.call(this, rawTokens);\n\n        Twig.log.debug('Twig.prepare: ', 'Compiled ', tokens);\n\n        return tokens;\n    };\n\n    /**\n     * Join the output token's stack and escape it if needed\n     *\n     * @param {Array} Output token's stack\n     *\n     * @return {string|String} Autoescaped output\n     */\n    Twig.output = function (output) {\n        const {autoescape} = this.options;\n\n        if (!autoescape) {\n            return output.join('');\n        }\n\n        const strategy = (typeof autoescape === 'string') ? autoescape : 'html';\n\n        const escapedOutput = output.map(str => {\n            if (\n                str &&\n                (str.twigMarkup !== true && str.twigMarkup !== strategy) &&\n                !(strategy === 'html' && str.twigMarkup === 'html_attr')\n            ) {\n                str = Twig.filters.escape(str, [strategy]);\n            }\n\n            return str;\n        });\n\n        if (escapedOutput.length === 0) {\n            return '';\n        }\n\n        const joinedOutput = escapedOutput.join('');\n        if (joinedOutput.length === 0) {\n            return '';\n        }\n\n        return new Twig.Markup(joinedOutput, true);\n    };\n\n    // Namespace for template storage and retrieval\n    Twig.Templates = {\n        /**\n         * Registered template loaders - use Twig.Templates.registerLoader to add supported loaders\n         * @type {Object}\n         */\n        loaders: {},\n\n        /**\n         * Registered template parsers - use Twig.Templates.registerParser to add supported parsers\n         * @type {Object}\n         */\n        parsers: {},\n\n        /**\n         * Cached / loaded templates\n         * @type {Object}\n         */\n        registry: {}\n    };\n\n    /**\n     * Is this id valid for a twig template?\n     *\n     * @param {string} id The ID to check.\n     *\n     * @throws {Twig.Error} If the ID is invalid or used.\n     * @return {boolean} True if the ID is valid.\n     */\n    Twig.validateId = function (id) {\n        if (id === 'prototype') {\n            throw new Twig.Error(id + ' is not a valid twig identifier');\n        } else if (Twig.cache && Object.hasOwnProperty.call(Twig.Templates.registry, id)) {\n            throw new Twig.Error('There is already a template with the ID ' + id);\n        }\n\n        return true;\n    };\n\n    /**\n     * Register a template loader\n     *\n     * @example\n     * Twig.extend(function (Twig) {\n     *    Twig.Templates.registerLoader('custom_loader', function (location, params, callback, errorCallback) {\n     *        // ... load the template ...\n     *        params.data = loadedTemplateData;\n     *        // create and return the template\n     *        var template = new Twig.Template(params);\n     *        if (typeof callback === 'function') {\n     *            callback(template);\n     *        }\n     *        return template;\n     *    });\n     * });\n     *\n     * @param {String} methodName The method this loader is intended for (ajax, fs)\n     * @param {Function} func The function to execute when loading the template\n     * @param {Object|undefined} scope Optional scope parameter to bind func to\n     *\n     * @throws Twig.Error\n     *\n     * @return {void}\n     */\n    Twig.Templates.registerLoader = function (methodName, func, scope) {\n        if (typeof func !== 'function') {\n            throw new Twig.Error('Unable to add loader for ' + methodName + ': Invalid function reference given.');\n        }\n\n        if (scope) {\n            func = func.bind(scope);\n        }\n\n        this.loaders[methodName] = func;\n    };\n\n    /**\n     * Remove a registered loader\n     *\n     * @param {String} methodName The method name for the loader you wish to remove\n     *\n     * @return {void}\n     */\n    Twig.Templates.unRegisterLoader = function (methodName) {\n        if (this.isRegisteredLoader(methodName)) {\n            delete this.loaders[methodName];\n        }\n    };\n\n    /**\n     * See if a loader is registered by its method name\n     *\n     * @param {String} methodName The name of the loader you are looking for\n     *\n     * @return {boolean}\n     */\n    Twig.Templates.isRegisteredLoader = function (methodName) {\n        return Object.hasOwnProperty.call(this.loaders, methodName);\n    };\n\n    /**\n     * Register a template parser\n     *\n     * @example\n     * Twig.extend(function (Twig) {\n     *    Twig.Templates.registerParser('custom_parser', function (params) {\n     *        // this template source can be accessed in params.data\n     *        var template = params.data\n     *\n     *        // ... custom process that modifies the template\n     *\n     *        // return the parsed template\n     *        return template;\n     *    });\n     * });\n     *\n     * @param {String} methodName The method this parser is intended for (twig, source)\n     * @param {Function} func The function to execute when parsing the template\n     * @param {Object|undefined} scope Optional scope parameter to bind func to\n     *\n     * @throws Twig.Error\n     *\n     * @return {void}\n     */\n    Twig.Templates.registerParser = function (methodName, func, scope) {\n        if (typeof func !== 'function') {\n            throw new Twig.Error('Unable to add parser for ' + methodName + ': Invalid function regerence given.');\n        }\n\n        if (scope) {\n            func = func.bind(scope);\n        }\n\n        this.parsers[methodName] = func;\n    };\n\n    /**\n     * Remove a registered parser\n     *\n     * @param {String} methodName The method name for the parser you wish to remove\n     *\n     * @return {void}\n     */\n    Twig.Templates.unRegisterParser = function (methodName) {\n        if (this.isRegisteredParser(methodName)) {\n            delete this.parsers[methodName];\n        }\n    };\n\n    /**\n     * See if a parser is registered by its method name\n     *\n     * @param {String} methodName The name of the parser you are looking for\n     *\n     * @return {boolean}\n     */\n    Twig.Templates.isRegisteredParser = function (methodName) {\n        return Object.hasOwnProperty.call(this.parsers, methodName);\n    };\n\n    /**\n     * Save a template object to the store.\n     *\n     * @param {Twig.Template} template   The twig.js template to store.\n     */\n    Twig.Templates.save = function (template) {\n        if (template.id === undefined) {\n            throw new Twig.Error('Unable to save template with no id');\n        }\n\n        Twig.Templates.registry[template.id] = template;\n    };\n\n    /**\n     * Load a previously saved template from the store.\n     *\n     * @param {string} id   The ID of the template to load.\n     *\n     * @return {Twig.Template} A twig.js template stored with the provided ID.\n     */\n    Twig.Templates.load = function (id) {\n        if (!Object.hasOwnProperty.call(Twig.Templates.registry, id)) {\n            return null;\n        }\n\n        return Twig.Templates.registry[id];\n    };\n\n    /**\n     * Load a template from a remote location using AJAX and saves in with the given ID.\n     *\n     * Available parameters:\n     *\n     *      async:       Should the HTTP request be performed asynchronously.\n     *                      Defaults to true.\n     *      method:      What method should be used to load the template\n     *                      (fs or ajax)\n     *      parser:      What method should be used to parse the template\n     *                      (twig or source)\n     *      precompiled: Has the template already been compiled.\n     *\n     * @param {string} location  The remote URL to load as a template.\n     * @param {Object} params The template parameters.\n     * @param {function} callback  A callback triggered when the template finishes loading.\n     * @param {function} errorCallback  A callback triggered if an error occurs loading the template.\n     *\n     *\n     */\n    Twig.Templates.loadRemote = function (location, params, callback, errorCallback) {\n        // Default to the URL so the template is cached.\n        const id = typeof params.id === 'undefined' ? location : params.id;\n        const cached = Twig.Templates.registry[id];\n\n        // Check for existing template\n        if (Twig.cache && typeof cached !== 'undefined') {\n            // A template is already saved with the given id.\n            if (typeof callback === 'function') {\n                callback(cached);\n            }\n            // TODO: if async, return deferred promise\n\n            return cached;\n        }\n\n        // If the parser name hasn't been set, default it to twig\n        params.parser = params.parser || 'twig';\n        params.id = id;\n\n        // Default to async\n        if (typeof params.async === 'undefined') {\n            params.async = true;\n        }\n\n        // Assume 'fs' if the loader is not defined\n        const loader = this.loaders[params.method] || this.loaders.fs;\n        return loader.call(this, location, params, callback, errorCallback);\n    };\n\n    // Determine object type\n    function is(type, obj) {\n        const clas = Object.prototype.toString.call(obj).slice(8, -1);\n        return obj !== undefined && obj !== null && clas === type;\n    }\n\n    /**\n     * A wrapper for template blocks.\n     *\n     * @param  {Twig.Template} The template that the block was originally defined in.\n     * @param  {Object} The compiled block token.\n     */\n    Twig.Block = function (template, token) {\n        this.template = template;\n        this.token = token;\n    };\n\n    /**\n     * Render the block using a specific parse state and context.\n     *\n     * @param  {Twig.ParseState} parseState\n     * @param  {Object} context\n     *\n     * @return {Promise}\n     */\n    Twig.Block.prototype.render = function (parseState, context) {\n        const originalTemplate = parseState.template;\n        let promise;\n\n        parseState.template = this.template;\n\n        if (this.token.expression) {\n            promise = Twig.expression.parseAsync.call(parseState, this.token.output, context);\n        } else {\n            promise = parseState.parseAsync(this.token.output, context);\n        }\n\n        return promise\n            .then(value => {\n                return Twig.expression.parseAsync.call(\n                    parseState,\n                    {\n                        type: Twig.expression.type.string,\n                        value\n                    },\n                    context\n                );\n            })\n            .then(output => {\n                parseState.template = originalTemplate;\n\n                return output;\n            });\n    };\n\n    /**\n     * Holds the state needed to parse a template.\n     *\n     * @param {Twig.Template} template The template that the tokens being parsed are associated with.\n     * @param {Object} blockOverrides Any blocks that should override those defined in the associated template.\n     */\n    Twig.ParseState = function (template, blockOverrides) {\n        this.renderedBlocks = {};\n        this.overrideBlocks = blockOverrides === undefined ? {} : blockOverrides;\n        this.context = {};\n        this.macros = {};\n        this.nestingStack = [];\n        this.template = template;\n    };\n\n    /**\n     * Get a block by its name, resolving in the following order:\n     *     - override blocks specified when initialized (except when excluded)\n     *     - blocks resolved from the associated template\n     *     - blocks resolved from the parent template when extending\n     *\n     * @param {String} name The name of the block to return.\n     * @param {Boolean} checkOnlyInheritedBlocks Whether to skip checking the overrides and associated template, will not skip by default.\n     *\n     * @return {Twig.Block|undefined}\n     */\n    Twig.ParseState.prototype.getBlock = function (name, checkOnlyInheritedBlocks) {\n        let block;\n\n        if (checkOnlyInheritedBlocks !== true) {\n            // Blocks specified when initialized\n            block = this.overrideBlocks[name];\n        }\n\n        if (block === undefined) {\n            // Block defined by the associated template\n            block = this.template.getBlock(name, checkOnlyInheritedBlocks);\n        }\n\n        if (block === undefined && this.template.parentTemplate !== null) {\n            // Block defined in the parent template when extending\n            block = this.template.parentTemplate.getBlock(name);\n        }\n\n        return block;\n    };\n\n    /**\n     * Get all the available blocks, resolving in the following order:\n     *     - override blocks specified when initialized\n     *     - blocks resolved from the associated template\n     *     - blocks resolved from the parent template when extending (except when excluded)\n     *\n     * @param {Boolean} includeParentBlocks Whether to get blocks from the parent template when extending, will always do so by default.\n     *\n     * @return {Object}\n     */\n    Twig.ParseState.prototype.getBlocks = function (includeParentBlocks) {\n        let blocks = {};\n\n        if (includeParentBlocks !== false &&\n            this.template.parentTemplate !== null &&\n            // Prevent infinite loop\n            this.template.parentTemplate !== this.template\n        ) {\n            // Blocks from the parent template when extending\n            blocks = this.template.parentTemplate.getBlocks();\n        }\n\n        blocks = {\n            ...blocks,\n            // Override with any blocks defined within the associated template\n            ...this.template.getBlocks(),\n            // Override with any blocks specified when initialized\n            ...this.overrideBlocks\n        };\n\n        return blocks;\n    };\n\n    /**\n     * Get the closest token of a specific type to the current nest level.\n     *\n     * @param  {String} type  The logic token type\n     *\n     * @return {Object}\n     */\n    Twig.ParseState.prototype.getNestingStackToken = function (type) {\n        let matchingToken;\n\n        this.nestingStack.forEach(token => {\n            if (matchingToken === undefined && token.type === type) {\n                matchingToken = token;\n            }\n        });\n\n        return matchingToken;\n    };\n\n    /**\n     * Parse a set of tokens using the current state.\n     *\n     * @param {Array} tokens The compiled tokens.\n     * @param {Object} context The context to set the state to while parsing.\n     * @param {Boolean} allowAsync Whether to parse asynchronously.\n     * @param {Object} blocks Blocks that should override any defined while parsing.\n     *\n     * @return {String} The rendered tokens.\n     *\n     */\n    Twig.ParseState.prototype.parse = function (tokens, context, allowAsync) {\n        const state = this;\n        let output = [];\n\n        // Store any error that might be thrown by the promise chain.\n        let err = null;\n\n        // This will be set to isAsync if template renders synchronously\n        let isAsync = true;\n        let promise = null;\n        // Track logic chains\n        let chain = true;\n\n        if (context) {\n            state.context = context;\n        }\n\n        /*\n         * Extracted into it's own function such that the function\n         * does not get recreated over and over again in the `forEach`\n         * loop below. This method can be compiled and optimized\n         * a single time instead of being recreated on each iteration.\n         */\n        function outputPush(o) {\n            output.push(o);\n        }\n\n        function parseTokenLogic(logic) {\n            if (typeof logic.chain !== 'undefined') {\n                chain = logic.chain;\n            }\n\n            if (typeof logic.context !== 'undefined') {\n                state.context = logic.context;\n            }\n\n            if (typeof logic.output !== 'undefined') {\n                output.push(logic.output);\n            }\n        }\n\n        promise = Twig.async.forEach(tokens, token => {\n            Twig.log.debug('Twig.ParseState.parse: ', 'Parsing token: ', token);\n\n            switch (token.type) {\n                case Twig.token.type.raw:\n                    output.push(Twig.filters.raw(token.value));\n                    break;\n\n                case Twig.token.type.logic:\n                    return Twig.logic.parseAsync.call(state, token.token /* logicToken */, state.context, chain)\n                        .then(parseTokenLogic);\n                case Twig.token.type.comment:\n                    // Do nothing, comments should be ignored\n                    break;\n\n                // Fall through whitespace to output\n                case Twig.token.type.outputWhitespacePre:\n                case Twig.token.type.outputWhitespacePost:\n                case Twig.token.type.outputWhitespaceBoth:\n                case Twig.token.type.output:\n                    Twig.log.debug('Twig.ParseState.parse: ', 'Output token: ', token.stack);\n                    // Parse the given expression in the given context\n                    return Twig.expression.parseAsync.call(state, token.stack, state.context)\n                        .then(outputPush);\n                default:\n                    break;\n            }\n        }).then(() => {\n            output = Twig.output.call(state.template, output);\n            isAsync = false;\n            return output;\n        }).catch(error => {\n            if (allowAsync) {\n                handleException(state, error);\n            }\n\n            err = error;\n        });\n\n        // If `allowAsync` we will always return a promise since we do not\n        // know in advance if we are going to run asynchronously or not.\n        if (allowAsync) {\n            return promise;\n        }\n\n        // Handle errors here if we fail synchronously.\n        if (err !== null) {\n            return handleException(state, err);\n        }\n\n        // If `allowAsync` is not true we should not allow the user\n        // to use asynchronous functions or filters.\n        if (isAsync) {\n            throw new Twig.Error('You are using Twig.js in sync mode in combination with async extensions.');\n        }\n\n        return output;\n    };\n\n    /**\n     * Create a new twig.js template.\n     *\n     * Parameters: {\n     *      data:   The template, either pre-compiled tokens or a string template\n     *      id:     The name of this template\n     * }\n     *\n     * @param {Object} params The template parameters.\n     */\n    Twig.Template = function (params) {\n        const {data, id, base, path, url, name, method, options} = params;\n\n        // # What is stored in a Twig.Template\n        //\n        // The Twig Template hold several chucks of data.\n        //\n        //     {\n        //          id:     The token ID (if any)\n        //          tokens: The list of tokens that makes up this template.\n        //          base:   The base template (if any)\n        //            options:  {\n        //                Compiler/parser options\n        //\n        //                strict_variables: true/false\n        //                    Should missing variable/keys emit an error message. If false, they default to null.\n        //            }\n        //     }\n        //\n\n        this.base = base;\n        this.blocks = {\n            defined: {},\n            imported: {}\n        };\n        this.id = id;\n        this.method = method;\n        this.name = name;\n        this.options = options;\n        this.parentTemplate = null;\n        this.path = path;\n        this.url = url;\n\n        if (is('String', data)) {\n            this.tokens = Twig.prepare.call(this, data);\n        } else {\n            this.tokens = data;\n        }\n\n        if (id !== undefined) {\n            Twig.Templates.save(this);\n        }\n    };\n\n    /**\n     * Get a block by its name, resolving in the following order:\n     *     - blocks defined in the template itself\n     *     - blocks imported from another template\n     *\n     * @param {String} name The name of the block to return.\n     * @param {Boolean} checkOnlyInheritedBlocks Whether to skip checking the blocks defined in the template itself, will not skip by default.\n     *\n     * @return {Twig.Block|undefined}\n     */\n    Twig.Template.prototype.getBlock = function (name, checkOnlyInheritedBlocks, checkImports = true) {\n        let block;\n\n        if (checkOnlyInheritedBlocks !== true) {\n            block = this.blocks.defined[name];\n        }\n\n        if (checkImports && block === undefined) {\n            block = this.blocks.imported[name];\n        }\n\n        if (block === undefined && this.parentTemplate !== null) {\n            /**\n             * Block defined in the parent template when extending.\n             * This recursion is useful to inherit from ascendants.\n             * But take care of not considering ascendants' {% use %}\n             */\n            block = this.parentTemplate.getBlock(name, checkOnlyInheritedBlocks, checkImports = false);\n        }\n\n        return block;\n    };\n\n    /**\n     * Get all the available blocks, resolving in the following order:\n     *     - blocks defined in the template itself\n     *     - blocks imported from other templates\n     *\n     * @return {Object}\n     */\n    Twig.Template.prototype.getBlocks = function () {\n        let blocks = {};\n\n        blocks = {\n            ...blocks,\n            // Get any blocks imported from other templates\n            ...this.blocks.imported,\n            // Override with any blocks defined within the template itself\n            ...this.blocks.defined\n        };\n\n        return blocks;\n    };\n\n    Twig.Template.prototype.render = function (context, params, allowAsync) {\n        const template = this;\n\n        params = params || {};\n\n        return Twig.async.potentiallyAsync(template, allowAsync, () => {\n            const state = new Twig.ParseState(template, params.blocks);\n\n            return state.parseAsync(template.tokens, context)\n                .then(output => {\n                    let parentTemplate;\n                    let url;\n\n                    if (template.parentTemplate !== null) {\n                        // This template extends another template\n\n                        if (template.options.allowInlineIncludes) {\n                            // The template is provided inline\n                            parentTemplate = Twig.Templates.load(template.parentTemplate);\n\n                            if (parentTemplate) {\n                                parentTemplate.options = template.options;\n                            }\n                        }\n\n                        // Check for the template file via include\n                        if (!parentTemplate) {\n                            url = Twig.path.parsePath(template, template.parentTemplate);\n\n                            parentTemplate = Twig.Templates.loadRemote(url, {\n                                method: template.getLoaderMethod(),\n                                base: template.base,\n                                async: false,\n                                id: url,\n                                options: template.options\n                            });\n                        }\n\n                        template.parentTemplate = parentTemplate;\n\n                        return template.parentTemplate.renderAsync(\n                            state.context,\n                            {\n                                blocks: state.getBlocks(false),\n                                isInclude: true\n                            }\n                        );\n                    }\n\n                    if (params.isInclude === true) {\n                        return output;\n                    }\n\n                    return output.valueOf();\n                });\n        });\n    };\n\n    Twig.Template.prototype.importFile = function (file) {\n        let url = null;\n        let subTemplate;\n        if (!this.url && this.options.allowInlineIncludes) {\n            file = this.path ? Twig.path.parsePath(this, file) : file;\n            subTemplate = Twig.Templates.load(file);\n\n            if (!subTemplate) {\n                subTemplate = Twig.Templates.loadRemote(url, {\n                    id: file,\n                    method: this.getLoaderMethod(),\n                    async: false,\n                    path: file,\n                    options: this.options\n                });\n\n                if (!subTemplate) {\n                    throw new Twig.Error('Unable to find the template ' + file);\n                }\n            }\n\n            subTemplate.options = this.options;\n\n            return subTemplate;\n        }\n\n        url = Twig.path.parsePath(this, file);\n\n        // Load blocks from an external file\n        subTemplate = Twig.Templates.loadRemote(url, {\n            method: this.getLoaderMethod(),\n            base: this.base,\n            async: false,\n            options: this.options,\n            id: url\n        });\n\n        return subTemplate;\n    };\n\n    Twig.Template.prototype.getLoaderMethod = function () {\n        if (this.path) {\n            return 'fs';\n        }\n\n        if (this.url) {\n            return 'ajax';\n        }\n\n        return this.method || 'fs';\n    };\n\n    Twig.Template.prototype.compile = function (options) {\n        // Compile the template into raw JS\n        return Twig.compiler.compile(this, options);\n    };\n\n    /**\n     * Create safe output\n     *\n     * @param {string} Content safe to output\n     *\n     * @return {String} Content wrapped into a String\n     */\n\n    Twig.Markup = function (content, strategy) {\n        if (typeof content !== 'string') {\n            return content;\n        }\n\n        /* eslint-disable no-new-wrappers, unicorn/new-for-builtins */\n        const output = new String(content);\n        /* eslint-enable */\n        output.twigMarkup = (typeof strategy === 'undefined') ? true : strategy;\n\n        return output;\n    };\n\n    return Twig;\n};\n","// ## twig.compiler.js\n//\n// This file handles compiling templates into JS\nmodule.exports = function (Twig) {\n    /**\n     * Namespace for compilation.\n     */\n    Twig.compiler = {\n        module: {}\n    };\n\n    // Compile a Twig Template to output.\n    Twig.compiler.compile = function (template, options) {\n        // Get tokens\n        const tokens = JSON.stringify(template.tokens);\n        const {id} = template;\n        let output = null;\n\n        if (options.module) {\n            if (Twig.compiler.module[options.module] === undefined) {\n                throw new Twig.Error('Unable to find module type ' + options.module);\n            }\n\n            output = Twig.compiler.module[options.module](id, tokens, options.twig);\n        } else {\n            output = Twig.compiler.wrap(id, tokens);\n        }\n\n        return output;\n    };\n\n    Twig.compiler.module = {\n        amd(id, tokens, pathToTwig) {\n            return 'define([\"' + pathToTwig + '\"], function (Twig) {\\n\\tvar twig, templates;\\ntwig = Twig.twig;\\ntemplates = ' + Twig.compiler.wrap(id, tokens) + '\\n\\treturn templates;\\n});';\n        },\n        node(id, tokens) {\n            return 'var twig = require(\"twig\").twig;\\nexports.template = ' + Twig.compiler.wrap(id, tokens);\n        },\n        cjs2(id, tokens, pathToTwig) {\n            return 'module.declare([{ twig: \"' + pathToTwig + '\" }], function (require, exports, module) {\\n\\tvar twig = require(\"twig\").twig;\\n\\texports.template = ' + Twig.compiler.wrap(id, tokens) + '\\n});';\n        }\n    };\n\n    Twig.compiler.wrap = function (id, tokens) {\n        return 'twig({id:\"' + id.replace('\"', '\\\\\"') + '\", data:' + tokens + ', precompiled: true});\\n';\n    };\n\n    return Twig;\n};\n","// ## twig.expression.js\n//\n// This file handles tokenizing, compiling and parsing expressions.\nmodule.exports = function (Twig) {\n    'use strict';\n\n    function parseParams(state, params, context) {\n        if (params) {\n            return Twig.expression.parseAsync.call(state, params, context);\n        }\n\n        return Twig.Promise.resolve(false);\n    }\n\n    /**\n     * Namespace for expression handling.\n     */\n    Twig.expression = { };\n\n    require('./twig.expression.operator')(Twig);\n\n    /**\n     * Reserved word that can't be used as variable names.\n     */\n    Twig.expression.reservedWords = [\n        'true', 'false', 'null', 'TRUE', 'FALSE', 'NULL', '_context', 'and', 'b-and', 'or', 'b-or', 'b-xor', 'in', 'not in', 'if', 'matches', 'starts', 'ends', 'with'\n    ];\n\n    /**\n     * The type of tokens used in expressions.\n     */\n    Twig.expression.type = {\n        comma: 'Twig.expression.type.comma',\n        operator: {\n            unary: 'Twig.expression.type.operator.unary',\n            binary: 'Twig.expression.type.operator.binary'\n        },\n        string: 'Twig.expression.type.string',\n        bool: 'Twig.expression.type.bool',\n        slice: 'Twig.expression.type.slice',\n        array: {\n            start: 'Twig.expression.type.array.start',\n            end: 'Twig.expression.type.array.end'\n        },\n        object: {\n            start: 'Twig.expression.type.object.start',\n            end: 'Twig.expression.type.object.end'\n        },\n        parameter: {\n            start: 'Twig.expression.type.parameter.start',\n            end: 'Twig.expression.type.parameter.end'\n        },\n        subexpression: {\n            start: 'Twig.expression.type.subexpression.start',\n            end: 'Twig.expression.type.subexpression.end'\n        },\n        key: {\n            period: 'Twig.expression.type.key.period',\n            brackets: 'Twig.expression.type.key.brackets'\n        },\n        filter: 'Twig.expression.type.filter',\n        _function: 'Twig.expression.type._function',\n        variable: 'Twig.expression.type.variable',\n        number: 'Twig.expression.type.number',\n        _null: 'Twig.expression.type.null',\n        context: 'Twig.expression.type.context',\n        test: 'Twig.expression.type.test'\n    };\n\n    Twig.expression.set = {\n        // What can follow an expression (in general)\n        operations: [\n            Twig.expression.type.filter,\n            Twig.expression.type.operator.unary,\n            Twig.expression.type.operator.binary,\n            Twig.expression.type.array.end,\n            Twig.expression.type.object.end,\n            Twig.expression.type.parameter.end,\n            Twig.expression.type.subexpression.end,\n            Twig.expression.type.comma,\n            Twig.expression.type.test\n        ],\n        expressions: [\n            Twig.expression.type._function,\n            Twig.expression.type.bool,\n            Twig.expression.type.string,\n            Twig.expression.type.variable,\n            Twig.expression.type.number,\n            Twig.expression.type._null,\n            Twig.expression.type.context,\n            Twig.expression.type.parameter.start,\n            Twig.expression.type.array.start,\n            Twig.expression.type.object.start,\n            Twig.expression.type.subexpression.start,\n            Twig.expression.type.operator.unary\n        ]\n    };\n\n    // Most expressions allow a '.' or '[' after them, so we provide a convenience set\n    Twig.expression.set.operationsExtended = Twig.expression.set.operations.concat([\n        Twig.expression.type.key.period,\n        Twig.expression.type.key.brackets,\n        Twig.expression.type.slice\n    ]);\n\n    // Some commonly used compile and parse functions.\n    Twig.expression.fn = {\n        compile: {\n            push(token, stack, output) {\n                output.push(token);\n            },\n            pushBoth(token, stack, output) {\n                output.push(token);\n                stack.push(token);\n            }\n        },\n        parse: {\n            push(token, stack) {\n                stack.push(token);\n            },\n            pushValue(token, stack) {\n                stack.push(token.value);\n            }\n        }\n    };\n\n    // The regular expressions and compile/parse logic used to match tokens in expressions.\n    //\n    // Properties:\n    //\n    //      type:  The type of expression this matches\n    //\n    //      regex: One or more regular expressions that matche the format of the token.\n    //\n    //      next:  Valid tokens that can occur next in the expression.\n    //\n    // Functions:\n    //\n    //      compile: A function that compiles the raw regular expression match into a token.\n    //\n    //      parse:   A function that parses the compiled token into output.\n    //\n    Twig.expression.definitions = [\n        {\n            type: Twig.expression.type.test,\n            regex: /^is\\s+(not)?\\s*([a-zA-Z_]\\w*(\\s?as)?)/,\n            next: Twig.expression.set.operations.concat([Twig.expression.type.parameter.start]),\n            compile(token, stack, output) {\n                token.filter = token.match[2];\n                token.modifier = token.match[1];\n                delete token.match;\n                delete token.value;\n                output.push(token);\n            },\n            parse(token, stack, context) {\n                const value = stack.pop();\n                const state = this;\n\n                return parseParams(state, token.params, context)\n                    .then(params => {\n                        const result = Twig.test(token.filter, value, params);\n\n                        if (token.modifier === 'not') {\n                            stack.push(!result);\n                        } else {\n                            stack.push(result);\n                        }\n                    });\n            }\n        },\n        {\n            type: Twig.expression.type.comma,\n            // Match a comma\n            regex: /^,/,\n            next: Twig.expression.set.expressions.concat([Twig.expression.type.array.end, Twig.expression.type.object.end]),\n            compile(token, stack, output) {\n                let i = stack.length - 1;\n                let stackToken;\n\n                delete token.match;\n                delete token.value;\n\n                // Pop tokens off the stack until the start of the object\n                for (;i >= 0; i--) {\n                    stackToken = stack.pop();\n                    if (stackToken.type === Twig.expression.type.object.start ||\n                            stackToken.type === Twig.expression.type.parameter.start ||\n                            stackToken.type === Twig.expression.type.array.start) {\n                        stack.push(stackToken);\n                        break;\n                    }\n\n                    output.push(stackToken);\n                }\n\n                output.push(token);\n            }\n        },\n        {\n            /**\n             * Match a number (integer or decimal)\n             */\n            type: Twig.expression.type.number,\n            // Match a number\n            regex: /^-?\\d+(\\.\\d+)?/,\n            next: Twig.expression.set.operations,\n            compile(token, stack, output) {\n                token.value = Number(token.value);\n                output.push(token);\n            },\n            parse: Twig.expression.fn.parse.pushValue\n        },\n        {\n            type: Twig.expression.type.operator.binary,\n            // Match any of ??, ?:, +, *, /, -, %, ~, <, <=, >, >=, !=, ==, **, ?, :, and, b-and, or, b-or, b-xor, in, not in\n            // and, or, in, not in, matches, starts with, ends with can be followed by a space or parenthesis\n            regex: /(^\\?\\?|^\\?:|^(b-and)|^(b-or)|^(b-xor)|^[+\\-~%?]|^[:](?!\\d\\])|^[!=]==?|^[!<>]=?|^\\*\\*?|^\\/\\/?|^(and)[(|\\s+]|^(or)[(|\\s+]|^(in)[(|\\s+]|^(not in)[(|\\s+]|^(matches)|^(starts with)|^(ends with)|^\\.\\.)/,\n            next: Twig.expression.set.expressions,\n            transform(match, tokens) {\n                switch (match[0]) {\n                    case 'and(':\n                    case 'or(':\n                    case 'in(':\n                    case 'not in(':\n                        // Strip off the ( if it exists\n                        tokens[tokens.length - 1].value = match[2];\n                        return match[0];\n                    default:\n                        return '';\n                }\n            },\n            compile(token, stack, output) {\n                delete token.match;\n\n                token.value = token.value.trim();\n                const {value} = token;\n                const operator = Twig.expression.operator.lookup(value, token);\n\n                Twig.log.trace('Twig.expression.compile: ', 'Operator: ', operator, ' from ', value);\n\n                while (stack.length > 0 &&\n                       (stack[stack.length - 1].type === Twig.expression.type.operator.unary || stack[stack.length - 1].type === Twig.expression.type.operator.binary) &&\n                            (\n                                (operator.associativity === Twig.expression.operator.leftToRight &&\n                                 operator.precidence >= stack[stack.length - 1].precidence) ||\n\n                                (operator.associativity === Twig.expression.operator.rightToLeft &&\n                                 operator.precidence > stack[stack.length - 1].precidence)\n                            )\n                ) {\n                    const temp = stack.pop();\n                    output.push(temp);\n                }\n\n                if (value === ':') {\n                    // Check if this is a ternary or object key being set\n                    if (stack[stack.length - 1] && stack[stack.length - 1].value === '?') {\n                        // Continue as normal for a ternary\n                    } else {\n                        // This is not a ternary so we push the token to the output where it can be handled\n                        //   when the assocated object is closed.\n                        const keyToken = output.pop();\n\n                        if (keyToken.type === Twig.expression.type.string ||\n                                keyToken.type === Twig.expression.type.variable) {\n                            token.key = keyToken.value;\n                        } else if (keyToken.type === Twig.expression.type.number) {\n                            // Convert integer keys into string keys\n                            token.key = keyToken.value.toString();\n                        } else if (keyToken.expression &&\n                            (keyToken.type === Twig.expression.type.parameter.end ||\n                            keyToken.type === Twig.expression.type.subexpression.end)) {\n                            token.params = keyToken.params;\n                        } else {\n                            throw new Twig.Error('Unexpected value before \\':\\' of ' + keyToken.type + ' = ' + keyToken.value);\n                        }\n\n                        output.push(token);\n                    }\n                } else {\n                    stack.push(operator);\n                }\n            },\n            parse(token, stack, context) {\n                const state = this;\n\n                if (token.key) {\n                    // Handle ternary ':' operator\n                    stack.push(token);\n                } else if (token.params) {\n                    // Handle \"{(expression):value}\"\n                    return Twig.expression.parseAsync.call(state, token.params, context)\n                        .then(key => {\n                            token.key = key;\n                            stack.push(token);\n\n                            // If we're in a loop, we might need token.params later, especially in this form of \"(expression):value\"\n                            if (!context.loop) {\n                                delete (token.params);\n                            }\n                        });\n                } else {\n                    Twig.expression.operator.parse(token.value, stack);\n                }\n            }\n        },\n        {\n            type: Twig.expression.type.operator.unary,\n            // Match any of not\n            regex: /(^not\\s+)/,\n            next: Twig.expression.set.expressions,\n            compile(token, stack, output) {\n                delete token.match;\n\n                token.value = token.value.trim();\n                const {value} = token;\n                const operator = Twig.expression.operator.lookup(value, token);\n\n                Twig.log.trace('Twig.expression.compile: ', 'Operator: ', operator, ' from ', value);\n\n                while (stack.length > 0 &&\n                       (stack[stack.length - 1].type === Twig.expression.type.operator.unary || stack[stack.length - 1].type === Twig.expression.type.operator.binary) &&\n                            (\n                                (operator.associativity === Twig.expression.operator.leftToRight &&\n                                 operator.precidence >= stack[stack.length - 1].precidence) ||\n\n                                (operator.associativity === Twig.expression.operator.rightToLeft &&\n                                 operator.precidence > stack[stack.length - 1].precidence)\n                            )\n                ) {\n                    const temp = stack.pop();\n                    output.push(temp);\n                }\n\n                stack.push(operator);\n            },\n            parse(token, stack) {\n                Twig.expression.operator.parse(token.value, stack);\n            }\n        },\n        {\n            /**\n             * Match a string. This is anything between a pair of single or double quotes.\n             */\n            type: Twig.expression.type.string,\n            // See: http://blog.stevenlevithan.com/archives/match-quoted-string\n            regex: /^([\"'])(?:(?=(\\\\?))\\2[\\s\\S])*?\\1/,\n            next: Twig.expression.set.operationsExtended,\n            compile(token, stack, output) {\n                let {value} = token;\n                delete token.match;\n\n                // Remove the quotes from the string\n                if (value.slice(0, 1) === '\"') {\n                    value = value.replace('\\\\\"', '\"');\n                } else {\n                    value = value.replace('\\\\\\'', '\\'');\n                }\n\n                token.value = value.slice(1, -1).replace(/\\\\n/g, '\\n').replace(/\\\\r/g, '\\r');\n                Twig.log.trace('Twig.expression.compile: ', 'String value: ', token.value);\n                output.push(token);\n            },\n            parse: Twig.expression.fn.parse.pushValue\n        },\n        {\n            /**\n             * Match a subexpression set start.\n             */\n            type: Twig.expression.type.subexpression.start,\n            regex: /^\\(/,\n            next: Twig.expression.set.expressions.concat([Twig.expression.type.subexpression.end]),\n            compile(token, stack, output) {\n                token.value = '(';\n                output.push(token);\n                stack.push(token);\n            },\n            parse: Twig.expression.fn.parse.push\n        },\n        {\n            /**\n             * Match a subexpression set end.\n             */\n            type: Twig.expression.type.subexpression.end,\n            regex: /^\\)/,\n            next: Twig.expression.set.operationsExtended,\n            validate(match, tokens) {\n                // Iterate back through previous tokens to ensure we follow a subexpression start\n                let i = tokens.length - 1;\n                let foundSubexpressionStart = false;\n                let nextSubexpressionStartInvalid = false;\n                let unclosedParameterCount = 0;\n\n                while (!foundSubexpressionStart && i >= 0) {\n                    const token = tokens[i];\n\n                    foundSubexpressionStart = token.type === Twig.expression.type.subexpression.start;\n\n                    // If we have previously found a subexpression end, then this subexpression start is the start of\n                    // that subexpression, not the subexpression we are searching for\n                    if (foundSubexpressionStart && nextSubexpressionStartInvalid) {\n                        nextSubexpressionStartInvalid = false;\n                        foundSubexpressionStart = false;\n                    }\n\n                    // Count parameter tokens to ensure we dont return truthy for a parameter opener\n                    if (token.type === Twig.expression.type.parameter.start) {\n                        unclosedParameterCount++;\n                    } else if (token.type === Twig.expression.type.parameter.end) {\n                        unclosedParameterCount--;\n                    } else if (token.type === Twig.expression.type.subexpression.end) {\n                        nextSubexpressionStartInvalid = true;\n                    }\n\n                    i--;\n                }\n\n                // If we found unclosed parameters, return false\n                // If we didnt find subexpression start, return false\n                // Otherwise return true\n\n                return (foundSubexpressionStart && (unclosedParameterCount === 0));\n            },\n            compile(token, stack, output) {\n                // This is basically a copy of parameter end compilation\n                let stackToken;\n                const endToken = token;\n\n                stackToken = stack.pop();\n                while (stack.length > 0 && stackToken.type !== Twig.expression.type.subexpression.start) {\n                    output.push(stackToken);\n                    stackToken = stack.pop();\n                }\n\n                // Move contents of parens into preceding filter\n                const paramStack = [];\n                while (token.type !== Twig.expression.type.subexpression.start) {\n                    // Add token to arguments stack\n                    paramStack.unshift(token);\n                    token = output.pop();\n                }\n\n                paramStack.unshift(token);\n\n                // If the token at the top of the *stack* is a function token, pop it onto the output queue.\n                // Get the token preceding the parameters\n                stackToken = stack[stack.length - 1];\n\n                if (stackToken === undefined ||\n                    (stackToken.type !== Twig.expression.type._function &&\n                    stackToken.type !== Twig.expression.type.filter &&\n                    stackToken.type !== Twig.expression.type.test &&\n                    stackToken.type !== Twig.expression.type.key.brackets)) {\n                    endToken.expression = true;\n\n                    // Remove start and end token from stack\n                    paramStack.pop();\n                    paramStack.shift();\n\n                    endToken.params = paramStack;\n\n                    output.push(endToken);\n                } else {\n                    // This should never be hit\n                    endToken.expression = false;\n                    stackToken.params = paramStack;\n                }\n            },\n            parse(token, stack, context) {\n                const state = this;\n\n                if (token.expression) {\n                    return Twig.expression.parseAsync.call(state, token.params, context)\n                        .then(value => {\n                            stack.push(value);\n                        });\n                }\n\n                throw new Twig.Error('Unexpected subexpression end when token is not marked as an expression');\n            }\n        },\n        {\n            /**\n             * Match a parameter set start.\n             */\n            type: Twig.expression.type.parameter.start,\n            regex: /^\\(/,\n            next: Twig.expression.set.expressions.concat([Twig.expression.type.parameter.end]),\n            validate(match, tokens) {\n                const lastToken = tokens[tokens.length - 1];\n                // We can't use the regex to test if we follow a space because expression is trimmed\n                return lastToken && (!Twig.expression.reservedWords.includes(lastToken.value.trim()));\n            },\n            compile: Twig.expression.fn.compile.pushBoth,\n            parse: Twig.expression.fn.parse.push\n        },\n        {\n            /**\n             * Match a parameter set end.\n             */\n            type: Twig.expression.type.parameter.end,\n            regex: /^\\)/,\n            next: Twig.expression.set.operationsExtended,\n            compile(token, stack, output) {\n                let stackToken;\n                const endToken = token;\n\n                stackToken = stack.pop();\n                while (stack.length > 0 && stackToken.type !== Twig.expression.type.parameter.start) {\n                    output.push(stackToken);\n                    stackToken = stack.pop();\n                }\n\n                // Move contents of parens into preceding filter\n                const paramStack = [];\n                while (token.type !== Twig.expression.type.parameter.start) {\n                    // Add token to arguments stack\n                    paramStack.unshift(token);\n                    token = output.pop();\n                }\n\n                paramStack.unshift(token);\n\n                // Get the token preceding the parameters\n                token = output[output.length - 1];\n\n                if (token === undefined ||\n                    (token.type !== Twig.expression.type._function &&\n                    token.type !== Twig.expression.type.filter &&\n                    token.type !== Twig.expression.type.test &&\n                    token.type !== Twig.expression.type.key.brackets)) {\n                    endToken.expression = true;\n\n                    // Remove start and end token from stack\n                    paramStack.pop();\n                    paramStack.shift();\n\n                    endToken.params = paramStack;\n\n                    output.push(endToken);\n                } else {\n                    endToken.expression = false;\n                    token.params = paramStack;\n                }\n            },\n            parse(token, stack, context) {\n                const newArray = [];\n                let arrayEnded = false;\n                let value = null;\n                const state = this;\n\n                if (token.expression) {\n                    return Twig.expression.parseAsync.call(state, token.params, context)\n                        .then(value => {\n                            stack.push(value);\n                        });\n                }\n\n                while (stack.length > 0) {\n                    value = stack.pop();\n                    // Push values into the array until the start of the array\n                    if (value && value.type && value.type === Twig.expression.type.parameter.start) {\n                        arrayEnded = true;\n                        break;\n                    }\n\n                    newArray.unshift(value);\n                }\n\n                if (!arrayEnded) {\n                    throw new Twig.Error('Expected end of parameter set.');\n                }\n\n                stack.push(newArray);\n            }\n        },\n        {\n            type: Twig.expression.type.slice,\n            regex: /^\\[(\\d*:\\d*)\\]/,\n            next: Twig.expression.set.operationsExtended,\n            compile(token, stack, output) {\n                const sliceRange = token.match[1].split(':');\n\n                // SliceStart can be undefined when we pass parameters to the slice filter later\n                const sliceStart = (sliceRange[0]) ? parseInt(sliceRange[0], 10) : undefined;\n                const sliceEnd = (sliceRange[1]) ? parseInt(sliceRange[1], 10) : undefined;\n\n                token.value = 'slice';\n                token.params = [sliceStart, sliceEnd];\n\n                // SliceEnd can't be undefined as the slice filter doesn't check for this, but it does check the length\n                // of the params array, so just shorten it.\n                if (!sliceEnd) {\n                    token.params = [sliceStart];\n                }\n\n                output.push(token);\n            },\n            parse(token, stack) {\n                const input = stack.pop();\n                const {params} = token;\n                const state = this;\n\n                stack.push(Twig.filter.call(state, token.value, input, params));\n            }\n        },\n        {\n            /**\n             * Match an array start.\n             */\n            type: Twig.expression.type.array.start,\n            regex: /^\\[/,\n            next: Twig.expression.set.expressions.concat([Twig.expression.type.array.end]),\n            compile: Twig.expression.fn.compile.pushBoth,\n            parse: Twig.expression.fn.parse.push\n        },\n        {\n            /**\n             * Match an array end.\n             */\n            type: Twig.expression.type.array.end,\n            regex: /^\\]/,\n            next: Twig.expression.set.operationsExtended,\n            compile(token, stack, output) {\n                let i = stack.length - 1;\n                let stackToken;\n                // Pop tokens off the stack until the start of the object\n                for (;i >= 0; i--) {\n                    stackToken = stack.pop();\n                    if (stackToken.type === Twig.expression.type.array.start) {\n                        break;\n                    }\n\n                    output.push(stackToken);\n                }\n\n                output.push(token);\n            },\n            parse(token, stack) {\n                const newArray = [];\n                let arrayEnded = false;\n                let value = null;\n\n                while (stack.length > 0) {\n                    value = stack.pop();\n                    // Push values into the array until the start of the array\n                    if (value && value.type && value.type === Twig.expression.type.array.start) {\n                        arrayEnded = true;\n                        break;\n                    }\n\n                    newArray.unshift(value);\n                }\n\n                if (!arrayEnded) {\n                    throw new Twig.Error('Expected end of array.');\n                }\n\n                stack.push(newArray);\n            }\n        },\n        // Token that represents the start of a hash map '}'\n        //\n        // Hash maps take the form:\n        //    { \"key\": 'value', \"another_key\": item }\n        //\n        // Keys must be quoted (either single or double) and values can be any expression.\n        {\n            type: Twig.expression.type.object.start,\n            regex: /^\\{/,\n            next: Twig.expression.set.expressions.concat([Twig.expression.type.object.end]),\n            compile: Twig.expression.fn.compile.pushBoth,\n            parse: Twig.expression.fn.parse.push\n        },\n\n        // Token that represents the end of a Hash Map '}'\n        //\n        // This is where the logic for building the internal\n        // representation of a hash map is defined.\n        {\n            type: Twig.expression.type.object.end,\n            regex: /^\\}/,\n            next: Twig.expression.set.operationsExtended,\n            compile(token, stack, output) {\n                let i = stack.length - 1;\n                let stackToken;\n\n                // Pop tokens off the stack until the start of the object\n                for (;i >= 0; i--) {\n                    stackToken = stack.pop();\n                    if (stackToken && stackToken.type === Twig.expression.type.object.start) {\n                        break;\n                    }\n\n                    output.push(stackToken);\n                }\n\n                output.push(token);\n            },\n            parse(endToken, stack) {\n                const newObject = {};\n                let objectEnded = false;\n                let token = null;\n                let hasValue = false;\n                let value = null;\n\n                while (stack.length > 0) {\n                    token = stack.pop();\n                    // Push values into the array until the start of the object\n                    if (token && token.type && token.type === Twig.expression.type.object.start) {\n                        objectEnded = true;\n                        break;\n                    }\n\n                    if (token && token.type && (token.type === Twig.expression.type.operator.binary || token.type === Twig.expression.type.operator.unary) && token.key) {\n                        if (!hasValue) {\n                            throw new Twig.Error('Missing value for key \\'' + token.key + '\\' in object definition.');\n                        }\n\n                        newObject[token.key] = value;\n\n                        // Preserve the order that elements are added to the map\n                        // This is necessary since JavaScript objects don't\n                        // guarantee the order of keys\n                        if (newObject._keys === undefined) {\n                            newObject._keys = [];\n                        }\n\n                        newObject._keys.unshift(token.key);\n\n                        // Reset value check\n                        value = null;\n                        hasValue = false;\n                    } else {\n                        hasValue = true;\n                        value = token;\n                    }\n                }\n\n                if (!objectEnded) {\n                    throw new Twig.Error('Unexpected end of object.');\n                }\n\n                stack.push(newObject);\n            }\n        },\n\n        // Token representing a filter\n        //\n        // Filters can follow any expression and take the form:\n        //    expression|filter(optional, args)\n        //\n        // Filter parsing is done in the Twig.filters namespace.\n        {\n            type: Twig.expression.type.filter,\n            // Match a | then a letter or _, then any number of letters, numbers, _ or -\n            regex: /^\\|\\s?([a-zA-Z_][a-zA-Z0-9_-]*)/,\n            next: Twig.expression.set.operationsExtended.concat([\n                Twig.expression.type.parameter.start\n            ]),\n            compile(token, stack, output) {\n                token.value = token.match[1];\n                output.push(token);\n            },\n            parse(token, stack, context) {\n                const input = stack.pop();\n                const state = this;\n\n                return parseParams(state, token.params, context)\n                    .then(params => {\n                        return Twig.filter.call(state, token.value, input, params);\n                    })\n                    .then(value => {\n                        stack.push(value);\n                    });\n            }\n        },\n        {\n            type: Twig.expression.type._function,\n            // Match any letter or _, then any number of letters, numbers, _ or - followed by (\n            regex: /^([a-zA-Z_]\\w*)\\s*\\(/,\n            next: Twig.expression.type.parameter.start,\n            validate(match) {\n                // Make sure this function is not a reserved word\n                return match[1] && (!Twig.expression.reservedWords.includes(match[1]));\n            },\n            transform() {\n                return '(';\n            },\n            compile(token, stack, output) {\n                const fn = token.match[1];\n                token.fn = fn;\n                // Cleanup token\n                delete token.match;\n                delete token.value;\n\n                output.push(token);\n            },\n            parse(token, stack, context) {\n                const state = this;\n                const {fn} = token;\n                let value;\n\n                return parseParams(state, token.params, context)\n                    .then(params => {\n                        if (Twig.functions[fn]) {\n                        // Get the function from the built-in functions\n                            value = Twig.functions[fn].apply(state, params);\n                        } else if (typeof context[fn] === 'function') {\n                        // Get the function from the user/context defined functions\n                            value = context[fn](...params);\n                        } else {\n                            throw new Twig.Error(fn + ' function does not exist and is not defined in the context');\n                        }\n\n                        return value;\n                    })\n                    .then(result => {\n                        stack.push(result);\n                    });\n            }\n        },\n\n        // Token representing a variable.\n        //\n        // Variables can contain letters, numbers, underscores and\n        // dashes, but must start with a letter or underscore.\n        //\n        // Variables are retrieved from the render context and take\n        // the value of 'undefined' if the given variable doesn't\n        // exist in the context.\n        {\n            type: Twig.expression.type.variable,\n            // Match any letter or _, then any number of letters, numbers, _ or -\n            regex: /^[a-zA-Z_]\\w*/,\n            next: Twig.expression.set.operationsExtended.concat([\n                Twig.expression.type.parameter.start\n            ]),\n            compile: Twig.expression.fn.compile.push,\n            validate(match) {\n                return (!Twig.expression.reservedWords.includes(match[0]));\n            },\n            parse(token, stack, context) {\n                const state = this;\n\n                // Get the variable from the context\n                return Twig.expression.resolveAsync.call(state, context[token.value], context)\n                    .then(value => {\n                        if (state.template.options.strictVariables && value === undefined) {\n                            throw new Twig.Error('Variable \"' + token.value + '\" does not exist.');\n                        }\n\n                        stack.push(value);\n                    });\n            }\n        },\n        {\n            type: Twig.expression.type.key.period,\n            regex: /^\\.(\\w+)/,\n            next: Twig.expression.set.operationsExtended.concat([\n                Twig.expression.type.parameter.start\n            ]),\n            compile(token, stack, output) {\n                token.key = token.match[1];\n                delete token.match;\n                delete token.value;\n\n                output.push(token);\n            },\n            parse(token, stack, context, nextToken) {\n                const state = this;\n                const {key} = token;\n                const object = stack.pop();\n                let value;\n\n                if (object && !Object.prototype.hasOwnProperty.call(object, key) && state.template.options.strictVariables) {\n                    const keys = Object.keys(object);\n                    if (keys.length > 0) {\n                        throw new Twig.Error('Key \"' + key + '\" for object with keys \"' + Object.keys(object).join(', ') + '\" does not exist.');\n                    } else {\n                        throw new Twig.Error('Key \"' + key + '\" does not exist as the object is empty.');\n                    }\n                }\n\n                return parseParams(state, token.params, context)\n                    .then(params => {\n                        if (object === null || object === undefined) {\n                            value = undefined;\n                        } else {\n                            const capitalize = function (value) {\n                                return value.slice(0, 1).toUpperCase() + value.slice(1);\n                            };\n\n                            // Get the variable from the context\n                            if (typeof object === 'object' && key in object) {\n                                value = object[key];\n                            } else if (object['get' + capitalize(key)]) {\n                                value = object['get' + capitalize(key)];\n                            } else if (object['is' + capitalize(key)]) {\n                                value = object['is' + capitalize(key)];\n                            } else {\n                                value = undefined;\n                            }\n                        }\n\n                        // When resolving an expression we need to pass nextToken in case the expression is a function\n                        return Twig.expression.resolveAsync.call(state, value, context, params, nextToken, object);\n                    })\n                    .then(result => {\n                        stack.push(result);\n                    });\n            }\n        },\n        {\n            type: Twig.expression.type.key.brackets,\n            regex: /^\\[([^\\]:]*)\\]/,\n            next: Twig.expression.set.operationsExtended.concat([\n                Twig.expression.type.parameter.start\n            ]),\n            compile(token, stack, output) {\n                const match = token.match[1];\n                delete token.value;\n                delete token.match;\n\n                // The expression stack for the key\n                token.stack = Twig.expression.compile({\n                    value: match\n                }).stack;\n\n                output.push(token);\n            },\n            parse(token, stack, context, nextToken) {\n                // Evaluate key\n                const state = this;\n                let params = null;\n                let object;\n                let value;\n\n                return parseParams(state, token.params, context)\n                    .then(parameters => {\n                        params = parameters;\n                        return Twig.expression.parseAsync.call(state, token.stack, context);\n                    })\n                    .then(key => {\n                        object = stack.pop();\n\n                        if (object && !Object.prototype.hasOwnProperty.call(object, key) && state.template.options.strictVariables) {\n                            const keys = Object.keys(object);\n                            if (keys.length > 0) {\n                                throw new Twig.Error('Key \"' + key + '\" for array with keys \"' + keys.join(', ') + '\" does not exist.');\n                            } else {\n                                throw new Twig.Error('Key \"' + key + '\" does not exist as the array is empty.');\n                            }\n                        } else if (object === null || object === undefined) {\n                            return null;\n                        }\n\n                        // Get the variable from the context\n                        if (typeof object === 'object' && key in object) {\n                            value = object[key];\n                        } else {\n                            value = null;\n                        }\n\n                        // When resolving an expression we need to pass nextToken in case the expression is a function\n                        return Twig.expression.resolveAsync.call(state, value, object, params, nextToken);\n                    })\n                    .then(result => {\n                        stack.push(result);\n                    });\n            }\n        },\n        {\n            /**\n             * Match a null value.\n             */\n            type: Twig.expression.type._null,\n            // Match a number\n            regex: /^(null|NULL|none|NONE)/,\n            next: Twig.expression.set.operations,\n            compile(token, stack, output) {\n                delete token.match;\n                token.value = null;\n                output.push(token);\n            },\n            parse: Twig.expression.fn.parse.pushValue\n        },\n        {\n            /**\n             * Match the context\n             */\n            type: Twig.expression.type.context,\n            regex: /^_context/,\n            next: Twig.expression.set.operationsExtended.concat([\n                Twig.expression.type.parameter.start\n            ]),\n            compile: Twig.expression.fn.compile.push,\n            parse(token, stack, context) {\n                stack.push(context);\n            }\n        },\n        {\n            /**\n             * Match a boolean\n             */\n            type: Twig.expression.type.bool,\n            regex: /^(true|TRUE|false|FALSE)/,\n            next: Twig.expression.set.operations,\n            compile(token, stack, output) {\n                token.value = (token.match[0].toLowerCase() === 'true');\n                delete token.match;\n                output.push(token);\n            },\n            parse: Twig.expression.fn.parse.pushValue\n        }\n    ];\n\n    /**\n     * Resolve a context value.\n     *\n     * If the value is a function, it is executed with a context parameter.\n     *\n     * @param {string} key The context object key.\n     * @param {Object} context The render context.\n     */\n    Twig.expression.resolveAsync = function (value, context, params, nextToken, object) {\n        const state = this;\n\n        if (typeof value !== 'function') {\n            return Twig.Promise.resolve(value);\n        }\n\n        let promise = Twig.Promise.resolve(params);\n\n        /*\n        If value is a function, it will have been impossible during the compile stage to determine that a following\n        set of parentheses were parameters for this function.\n\n        Those parentheses will have therefore been marked as an expression, with their own parameters, which really\n        belong to this function.\n\n        Those parameters will also need parsing in case they are actually an expression to pass as parameters.\n            */\n        if (nextToken && nextToken.type === Twig.expression.type.parameter.end) {\n            // When parsing these parameters, we need to get them all back, not just the last item on the stack.\n            const tokensAreParameters = true;\n\n            promise = promise.then(() => {\n                return nextToken.params && Twig.expression.parseAsync.call(state, nextToken.params, context, tokensAreParameters);\n            })\n                .then(p => {\n                // Clean up the parentheses tokens on the next loop\n                    nextToken.cleanup = true;\n\n                    return p;\n                });\n        }\n\n        return promise.then(params => {\n            return value.apply(object || context, params || []);\n        });\n    };\n\n    Twig.expression.resolve = function (value, context, params, nextToken, object) {\n        return Twig.async.potentiallyAsync(this, false, function () {\n            return Twig.expression.resolveAsync.call(this, value, context, params, nextToken, object);\n        });\n    };\n\n    /**\n     * Registry for logic handlers.\n     */\n    Twig.expression.handler = {};\n\n    /**\n     * Define a new expression type, available at Twig.logic.type.{type}\n     *\n     * @param {string} type The name of the new type.\n     */\n    Twig.expression.extendType = function (type) {\n        Twig.expression.type[type] = 'Twig.expression.type.' + type;\n    };\n\n    /**\n     * Extend the expression parsing functionality with a new definition.\n     *\n     * Token definitions follow this format:\n     *  {\n     *      type:     One of Twig.expression.type.[type], either pre-defined or added using\n     *                    Twig.expression.extendType\n     *\n     *      next:     Array of types from Twig.expression.type that can follow this token,\n     *\n     *      regex:    A regex or array of regex's that should match the token.\n     *\n     *      compile: function(token, stack, output) called when this token is being compiled.\n     *                   Should return an object with stack and output set.\n     *\n     *      parse:   function(token, stack, context) called when this token is being parsed.\n     *                   Should return an object with stack and context set.\n     *  }\n     *\n     * @param {Object} definition A token definition.\n     */\n    Twig.expression.extend = function (definition) {\n        if (!definition.type) {\n            throw new Twig.Error('Unable to extend logic definition. No type provided for ' + definition);\n        }\n\n        Twig.expression.handler[definition.type] = definition;\n    };\n\n    // Extend with built-in expressions\n    while (Twig.expression.definitions.length > 0) {\n        Twig.expression.extend(Twig.expression.definitions.shift());\n    }\n\n    /**\n     * Break an expression into tokens defined in Twig.expression.definitions.\n     *\n     * @param {string} expression The string to tokenize.\n     *\n     * @return {Array} An array of tokens.\n     */\n    Twig.expression.tokenize = function (expression) {\n        const tokens = [];\n        // Keep an offset of the location in the expression for error messages.\n        let expOffset = 0;\n        // The valid next tokens of the previous token\n        let next = null;\n        // Match information\n        let type;\n        let regex;\n        let regexI;\n        // The possible next token for the match\n        let tokenNext;\n        // Has a match been found from the definitions\n        let matchFound;\n        let invalidMatches = [];\n\n        const matchFunction = function (...args) {\n            // Don't pass arguments to `Array.slice`, that is a performance killer\n            let matchI = arguments.length - 2;\n            const match = new Array(matchI);\n\n            while (matchI-- > 0) {\n                match[matchI] = args[matchI];\n            }\n\n            Twig.log.trace('Twig.expression.tokenize',\n                'Matched a ', type, ' regular expression of ', match);\n\n            if (next && !next.includes(type)) {\n                invalidMatches.push(\n                    type + ' cannot follow a ' + tokens[tokens.length - 1].type +\n                           ' at template:' + expOffset + ' near \\'' + match[0].slice(0, 20) +\n                           '...\\''\n                );\n\n                // Not a match, don't change the expression\n                return match[0];\n            }\n\n            const handler = Twig.expression.handler[type];\n\n            // Validate the token if a validation function is provided\n            if (handler.validate && !handler.validate(match, tokens)) {\n                return match[0];\n            }\n\n            invalidMatches = [];\n\n            tokens.push({\n                type,\n                value: match[0],\n                match\n            });\n\n            matchFound = true;\n            next = tokenNext;\n            expOffset += match[0].length;\n\n            // Does the token need to return output back to the expression string\n            // e.g. a function match of cycle( might return the '(' back to the expression\n            // This allows look-ahead to differentiate between token types (e.g. functions and variable names)\n            if (handler.transform) {\n                return handler.transform(match, tokens);\n            }\n\n            return '';\n        };\n\n        Twig.log.debug('Twig.expression.tokenize', 'Tokenizing expression ', expression);\n\n        while (expression.length > 0) {\n            expression = expression.trim();\n            for (type in Twig.expression.handler) {\n                if (Object.hasOwnProperty.call(Twig.expression.handler, type)) {\n                    tokenNext = Twig.expression.handler[type].next;\n                    regex = Twig.expression.handler[type].regex;\n                    Twig.log.trace('Checking type ', type, ' on ', expression);\n\n                    matchFound = false;\n\n                    if (Array.isArray(regex)) {\n                        regexI = regex.length;\n                        while (regexI-- > 0) {\n                            expression = expression.replace(regex[regexI], matchFunction);\n                        }\n                    } else {\n                        expression = expression.replace(regex, matchFunction);\n                    }\n\n                    // An expression token has been matched. Break the for loop and start trying to\n                    //  match the next template (if expression isn't empty.)\n                    if (matchFound) {\n                        break;\n                    }\n                }\n            }\n\n            if (!matchFound) {\n                if (invalidMatches.length > 0) {\n                    throw new Twig.Error(invalidMatches.join(' OR '));\n                } else {\n                    throw new Twig.Error('Unable to parse \\'' + expression + '\\' at template position' + expOffset);\n                }\n            }\n        }\n\n        Twig.log.trace('Twig.expression.tokenize', 'Tokenized to ', tokens);\n        return tokens;\n    };\n\n    /**\n     * Compile an expression token.\n     *\n     * @param {Object} rawToken The uncompiled token.\n     *\n     * @return {Object} The compiled token.\n     */\n    Twig.expression.compile = function (rawToken) {\n        const expression = rawToken.value;\n        // Tokenize expression\n        const tokens = Twig.expression.tokenize(expression);\n        let token = null;\n        const output = [];\n        const stack = [];\n        let tokenTemplate = null;\n\n        Twig.log.trace('Twig.expression.compile: ', 'Compiling ', expression);\n\n        // Push tokens into RPN stack using the Shunting-yard algorithm\n        // See http://en.wikipedia.org/wiki/Shunting_yard_algorithm\n\n        while (tokens.length > 0) {\n            token = tokens.shift();\n            tokenTemplate = Twig.expression.handler[token.type];\n\n            Twig.log.trace('Twig.expression.compile: ', 'Compiling ', token);\n\n            // Compile the template\n            tokenTemplate.compile(token, stack, output);\n\n            Twig.log.trace('Twig.expression.compile: ', 'Stack is', stack);\n            Twig.log.trace('Twig.expression.compile: ', 'Output is', output);\n        }\n\n        while (stack.length > 0) {\n            output.push(stack.pop());\n        }\n\n        Twig.log.trace('Twig.expression.compile: ', 'Final output is', output);\n\n        rawToken.stack = output;\n        delete rawToken.value;\n\n        return rawToken;\n    };\n\n    /**\n     * Parse an RPN expression stack within a context.\n     *\n     * @param {Array} tokens An array of compiled expression tokens.\n     * @param {Object} context The render context to parse the tokens with.\n     *\n     * @return {Object} The result of parsing all the tokens. The result\n     *                  can be anything, String, Array, Object, etc... based on\n     *                  the given expression.\n     */\n    Twig.expression.parse = function (tokens, context, tokensAreParameters, allowAsync) {\n        const state = this;\n\n        // If the token isn't an array, make it one.\n        if (!Array.isArray(tokens)) {\n            tokens = [tokens];\n        }\n\n        // The output stack\n        const stack = [];\n        const loopTokenFixups = [];\n        const binaryOperator = Twig.expression.type.operator.binary;\n\n        return Twig.async.potentiallyAsync(state, allowAsync, () => {\n            return Twig.async.forEach(tokens, (token, index) => {\n                let tokenTemplate = null;\n                let nextToken = null;\n                let result;\n\n                // If the token is marked for cleanup, we don't need to parse it\n                if (token.cleanup) {\n                    return;\n                }\n\n                // Determine the token that follows this one so that we can pass it to the parser\n                if (tokens.length > index + 1) {\n                    nextToken = tokens[index + 1];\n                }\n\n                tokenTemplate = Twig.expression.handler[token.type];\n\n                if (tokenTemplate.parse) {\n                    result = tokenTemplate.parse.call(state, token, stack, context, nextToken);\n                }\n\n                // Store any binary tokens for later if we are in a loop.\n                if (token.type === binaryOperator && context.loop) {\n                    loopTokenFixups.push(token);\n                }\n\n                return result;\n            })\n                .then(() => {\n                // Check every fixup and remove \"key\" as long as they still have \"params\". This covers the use case where\n                // a \":\" operator is used in a loop with a \"(expression):\" statement. We need to be able to evaluate the expression\n                    let len = loopTokenFixups.length;\n                    let loopTokenFixup = null;\n\n                    while (len-- > 0) {\n                        loopTokenFixup = loopTokenFixups[len];\n                        if (loopTokenFixup.params && loopTokenFixup.key) {\n                            delete loopTokenFixup.key;\n                        }\n                    }\n\n                    // If parse has been called with a set of tokens that are parameters, we need to return the whole stack,\n                    // wrapped in an Array.\n                    if (tokensAreParameters) {\n                        const params = stack.splice(0);\n\n                        stack.push(params);\n                    }\n\n                    // Pop the final value off the stack\n                    return stack.pop();\n                });\n        });\n    };\n\n    return Twig;\n};\n","var arrayWithoutHoles = require(\"./arrayWithoutHoles\");\n\nvar iterableToArray = require(\"./iterableToArray\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableSpread = require(\"./nonIterableSpread\");\n\nfunction _toConsumableArray(arr) {\n  return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();\n}\n\nmodule.exports = _toConsumableArray;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\n\nfunction _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}\n\nmodule.exports = _arrayWithoutHoles;","function _iterableToArray(iter) {\n  if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter);\n}\n\nmodule.exports = _iterableToArray;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\n\nfunction _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);\n}\n\nmodule.exports = _unsupportedIterableToArray;","function _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nmodule.exports = _nonIterableSpread;","// ## twig.expression.operator.js\n//\n// This file handles operator lookups and parsing.\nmodule.exports = function (Twig) {\n    'use strict';\n\n    /**\n     * Operator associativity constants.\n     */\n    Twig.expression.operator = {\n        leftToRight: 'leftToRight',\n        rightToLeft: 'rightToLeft'\n    };\n\n    const containment = function (a, b) {\n        if (b === undefined || b === null) {\n            return null;\n        }\n\n        if (b.indexOf !== undefined) {\n            // String\n            return (a === b || a !== '') && b.includes(a);\n        }\n\n        let el;\n        for (el in b) {\n            if (Object.hasOwnProperty.call(b, el) && b[el] === a) {\n                return true;\n            }\n        }\n\n        return false;\n    };\n\n    /**\n     * Get the precidence and associativity of an operator. These follow the order that C/C++ use.\n     * See http://en.wikipedia.org/wiki/Operators_in_C_and_C++ for the table of values.\n     */\n    Twig.expression.operator.lookup = function (operator, token) {\n        switch (operator) {\n            case '..':\n                token.precidence = 20;\n                token.associativity = Twig.expression.operator.leftToRight;\n                break;\n\n            case ',':\n                token.precidence = 18;\n                token.associativity = Twig.expression.operator.leftToRight;\n                break;\n\n            // Ternary\n            case '?:':\n            case '?':\n            case ':':\n                token.precidence = 16;\n                token.associativity = Twig.expression.operator.rightToLeft;\n                break;\n\n            // Null-coalescing operator\n            case '??':\n                token.precidence = 15;\n                token.associativity = Twig.expression.operator.rightToLeft;\n                break;\n\n            case 'or':\n                token.precidence = 14;\n                token.associativity = Twig.expression.operator.leftToRight;\n                break;\n\n            case 'and':\n                token.precidence = 13;\n                token.associativity = Twig.expression.operator.leftToRight;\n                break;\n\n            case 'b-or':\n                token.precidence = 12;\n                token.associativity = Twig.expression.operator.leftToRight;\n                break;\n\n            case 'b-xor':\n                token.precidence = 11;\n                token.associativity = Twig.expression.operator.leftToRight;\n                break;\n\n            case 'b-and':\n                token.precidence = 10;\n                token.associativity = Twig.expression.operator.leftToRight;\n                break;\n\n            case '==':\n            case '!=':\n                token.precidence = 9;\n                token.associativity = Twig.expression.operator.leftToRight;\n                break;\n\n            case '<':\n            case '<=':\n            case '>':\n            case '>=':\n            case 'not in':\n            case 'in':\n                token.precidence = 8;\n                token.associativity = Twig.expression.operator.leftToRight;\n                break;\n\n            case '~': // String concatination\n            case '+':\n            case '-':\n                token.precidence = 6;\n                token.associativity = Twig.expression.operator.leftToRight;\n                break;\n\n            case '//':\n            case '**':\n            case '*':\n            case '/':\n            case '%':\n                token.precidence = 5;\n                token.associativity = Twig.expression.operator.leftToRight;\n                break;\n\n            case 'not':\n                token.precidence = 3;\n                token.associativity = Twig.expression.operator.rightToLeft;\n                break;\n\n            case 'matches':\n                token.precidence = 8;\n                token.associativity = Twig.expression.operator.leftToRight;\n                break;\n\n            case 'starts with':\n                token.precidence = 8;\n                token.associativity = Twig.expression.operator.leftToRight;\n                break;\n\n            case 'ends with':\n                token.precidence = 8;\n                token.associativity = Twig.expression.operator.leftToRight;\n                break;\n\n            default:\n                throw new Twig.Error('Failed to lookup operator: ' + operator + ' is an unknown operator.');\n        }\n\n        token.operator = operator;\n        return token;\n    };\n\n    /**\n     * Handle operations on the RPN stack.\n     *\n     * Returns the updated stack.\n     */\n    Twig.expression.operator.parse = function (operator, stack) {\n        Twig.log.trace('Twig.expression.operator.parse: ', 'Handling ', operator);\n        let a;\n        let b;\n        let c;\n\n        if (operator === '?') {\n            c = stack.pop();\n        }\n\n        b = stack.pop();\n        if (operator !== 'not') {\n            a = stack.pop();\n        }\n\n        if (operator !== 'in' && operator !== 'not in' && operator !== '??') {\n            if (a && Array.isArray(a)) {\n                a = a.length;\n            }\n\n            if (operator !== '?' && (b && Array.isArray(b))) {\n                b = b.length;\n            }\n        }\n\n        if (operator === 'matches') {\n            if (b && typeof b === 'string') {\n                const reParts = b.match(/^\\/(.*)\\/([gims]?)$/);\n                const reBody = reParts[1];\n                const reFlags = reParts[2];\n                b = new RegExp(reBody, reFlags);\n            }\n        }\n\n        switch (operator) {\n            case ':':\n                // Ignore\n                break;\n\n            case '??':\n                if (a === undefined) {\n                    a = b;\n                    b = c;\n                    c = undefined;\n                }\n\n                if (a !== undefined && a !== null) {\n                    stack.push(a);\n                } else {\n                    stack.push(b);\n                }\n\n                break;\n            case '?:':\n                if (Twig.lib.boolval(a)) {\n                    stack.push(a);\n                } else {\n                    stack.push(b);\n                }\n\n                break;\n            case '?':\n                if (a === undefined) {\n                    // An extended ternary.\n                    a = b;\n                    b = c;\n                    c = undefined;\n                }\n\n                if (Twig.lib.boolval(a)) {\n                    stack.push(b);\n                } else {\n                    stack.push(c);\n                }\n\n                break;\n\n            case '+':\n                b = parseFloat(b);\n                a = parseFloat(a);\n                stack.push(a + b);\n                break;\n\n            case '-':\n                b = parseFloat(b);\n                a = parseFloat(a);\n                stack.push(a - b);\n                break;\n\n            case '*':\n                b = parseFloat(b);\n                a = parseFloat(a);\n                stack.push(a * b);\n                break;\n\n            case '/':\n                b = parseFloat(b);\n                a = parseFloat(a);\n                stack.push(a / b);\n                break;\n\n            case '//':\n                b = parseFloat(b);\n                a = parseFloat(a);\n                stack.push(Math.floor(a / b));\n                break;\n\n            case '%':\n                b = parseFloat(b);\n                a = parseFloat(a);\n                stack.push(a % b);\n                break;\n\n            case '~':\n                stack.push((typeof a !== 'undefined' && a !== null ? a.toString() : '') +\n                          (typeof b !== 'undefined' && b !== null ? b.toString() : ''));\n                break;\n\n            case 'not':\n            case '!':\n                stack.push(!Twig.lib.boolval(b));\n                break;\n\n            case '<':\n                stack.push(a < b);\n                break;\n\n            case '<=':\n                stack.push(a <= b);\n                break;\n\n            case '>':\n                stack.push(a > b);\n                break;\n\n            case '>=':\n                stack.push(a >= b);\n                break;\n\n            case '===':\n                stack.push(a === b);\n                break;\n\n            case '==':\n                /* eslint-disable-next-line eqeqeq */\n                stack.push(a == b);\n                break;\n\n            case '!==':\n                stack.push(a !== b);\n                break;\n\n            case '!=':\n                /* eslint-disable-next-line eqeqeq */\n                stack.push(a != b);\n                break;\n\n            case 'or':\n                stack.push(Twig.lib.boolval(a) || Twig.lib.boolval(b));\n                break;\n\n            case 'b-or':\n                stack.push(a | b);\n                break;\n\n            case 'b-xor':\n                stack.push(a ^ b);\n                break;\n\n            case 'and':\n                stack.push(Twig.lib.boolval(a) && Twig.lib.boolval(b));\n                break;\n\n            case 'b-and':\n                stack.push(a & b);\n                break;\n\n            case '**':\n                stack.push(a ** b);\n                break;\n\n            case 'not in':\n                stack.push(!containment(a, b));\n                break;\n\n            case 'in':\n                stack.push(containment(a, b));\n                break;\n\n            case 'matches':\n                stack.push(b.test(a));\n                break;\n\n            case 'starts with':\n                stack.push(typeof a === 'string' && a.indexOf(b) === 0);\n                break;\n\n            case 'ends with':\n                stack.push(typeof a === 'string' && a.includes(b, a.length - b.length));\n                break;\n\n            case '..':\n                stack.push(Twig.functions.range(a, b));\n                break;\n\n            default:\n                throw new Twig.Error('Failed to parse operator: ' + operator + ' is an unknown operator.');\n        }\n    };\n\n    return Twig;\n};\n","// ## twig.filters.js\n//\n// This file handles parsing filters.\nmodule.exports = function (Twig) {\n    // Determine object type\n    function is(type, obj) {\n        const clas = Object.prototype.toString.call(obj).slice(8, -1);\n        return obj !== undefined && obj !== null && clas === type;\n    }\n\n    Twig.filters = {\n        // String Filters\n        upper(value) {\n            if (typeof value !== 'string') {\n                return value;\n            }\n\n            return value.toUpperCase();\n        },\n        lower(value) {\n            if (typeof value !== 'string') {\n                return value;\n            }\n\n            return value.toLowerCase();\n        },\n        capitalize(value) {\n            if (typeof value !== 'string') {\n                return value;\n            }\n\n            return value.slice(0, 1).toUpperCase() + value.toLowerCase().slice(1);\n        },\n        title(value) {\n            if (typeof value !== 'string') {\n                return value;\n            }\n\n            return value.toLowerCase().replace(/(^|\\s)([a-z])/g, (m, p1, p2) => {\n                return p1 + p2.toUpperCase();\n            });\n        },\n        length(value) {\n            if (Twig.lib.is('Array', value) || typeof value === 'string') {\n                return value.length;\n            }\n\n            if (Twig.lib.is('Object', value)) {\n                if (value._keys === undefined) {\n                    return Object.keys(value).length;\n                }\n\n                return value._keys.length;\n            }\n\n            return 0;\n        },\n\n        // Array/Object Filters\n        reverse(value) {\n            if (is('Array', value)) {\n                return value.reverse();\n            }\n\n            if (is('String', value)) {\n                return value.split('').reverse().join('');\n            }\n\n            if (is('Object', value)) {\n                const keys = value._keys || Object.keys(value).reverse();\n                value._keys = keys;\n                return value;\n            }\n        },\n        sort(value) {\n            if (is('Array', value)) {\n                return value.sort();\n            }\n\n            if (is('Object', value)) {\n                // Sorting objects isn't obvious since the order of\n                // returned keys isn't guaranteed in JavaScript.\n                // Because of this we use a \"hidden\" key called _keys to\n                // store the keys in the order we want to return them.\n\n                delete value._keys;\n                const keys = Object.keys(value);\n                const sortedKeys = keys.sort((a, b) => {\n                    let a1;\n                    let b1;\n\n                    // If a and b are comparable, we're fine :-)\n                    if ((value[a] > value[b]) === !(value[a] <= value[b])) {\n                        return value[a] > value[b] ? 1 :\n                            (value[a] < value[b] ? -1 : 0);\n                    }\n\n                    // If a and b can be parsed as numbers, we can compare\n                    // their numeric value\n                    if (!isNaN(a1 = parseFloat(value[a])) &&\n                                !isNaN(b1 = parseFloat(value[b]))) {\n                        return a1 > b1 ? 1 : (a1 < b1 ? -1 : 0);\n                    }\n\n                    // If one of the values is a string, we convert the\n                    // other value to string as well\n                    if (typeof value[a] === 'string') {\n                        return value[a] > value[b].toString() ? 1 :\n                            (value[a] < value[b].toString() ? -1 : 0);\n                    }\n\n                    if (typeof value[b] === 'string') {\n                        return value[a].toString() > value[b] ? 1 :\n                            (value[a].toString() < value[b] ? -1 : 0);\n                    }\n                    // Everything failed - return 'null' as sign, that\n                    // the values are not comparable\n\n                    return null;\n                });\n                value._keys = sortedKeys;\n                return value;\n            }\n        },\n        keys(value) {\n            if (value === undefined || value === null) {\n                return;\n            }\n\n            const keyset = value._keys || Object.keys(value);\n            const output = [];\n\n            keyset.forEach(key => {\n                if (key === '_keys') {\n                    return;\n                } // Ignore the _keys property\n\n                if (Object.hasOwnProperty.call(value, key)) {\n                    output.push(key);\n                }\n            });\n            return output;\n        },\n        /* eslint-disable-next-line camelcase */\n        url_encode(value) {\n            if (value === undefined || value === null) {\n                return;\n            }\n\n            if (Twig.lib.is('Object', value)) {\n                const serialize = function (obj, prefix) {\n                    const result = [];\n                    const keyset = obj._keys || Object.keys(obj);\n\n                    keyset.forEach(key => {\n                        if (!Object.prototype.hasOwnProperty.call(obj, key)) {\n                            return;\n                        }\n\n                        const resultKey = prefix ? prefix + '[' + key + ']' : key;\n                        const resultValue = obj[key];\n\n                        result.push(\n                            (Twig.lib.is('Object', resultValue) || Array.isArray(resultValue)) ?\n                                serialize(resultValue, resultKey) :\n                                encodeURIComponent(resultKey) + '=' + encodeURIComponent(resultValue)\n                        );\n                    });\n\n                    return result.join('&amp;');\n                };\n\n                return serialize(value);\n            }\n\n            let result = encodeURIComponent(value);\n            result = result.replace('\\'', '%27');\n            return result;\n        },\n        join(value, params) {\n            if (value === undefined || value === null) {\n                return;\n            }\n\n            let joinStr = '';\n            let output = [];\n            let keyset = null;\n\n            if (params && params[0]) {\n                joinStr = params[0];\n            }\n\n            if (is('Array', value)) {\n                output = value;\n            } else {\n                keyset = value._keys || Object.keys(value);\n                keyset.forEach(key => {\n                    if (key === '_keys') {\n                        return;\n                    } // Ignore the _keys property\n\n                    if (Object.hasOwnProperty.call(value, key)) {\n                        output.push(value[key]);\n                    }\n                });\n            }\n\n            return output.join(joinStr);\n        },\n        default(value, params) {\n            if (params !== undefined && params.length > 1) {\n                throw new Twig.Error('default filter expects one argument');\n            }\n\n            if (value === undefined || value === null || value === '') {\n                if (params === undefined) {\n                    return '';\n                }\n\n                return params[0];\n            }\n\n            return value;\n        },\n        /* eslint-disable-next-line camelcase */\n        json_encode(value) {\n            if (value === undefined || value === null) {\n                return 'null';\n            }\n\n            if ((typeof value === 'object') && (is('Array', value))) {\n                const output = [];\n\n                value.forEach(v => {\n                    output.push(Twig.filters.json_encode(v));\n                });\n\n                return '[' + output.join(',') + ']';\n            }\n\n            if ((typeof value === 'object') && (is('Date', value))) {\n                return '\"' + value.toISOString() + '\"';\n            }\n\n            if (typeof value === 'object') {\n                const keyset = value._keys || Object.keys(value);\n                const output = [];\n\n                keyset.forEach(key => {\n                    output.push(JSON.stringify(key) + ':' + Twig.filters.json_encode(value[key]));\n                });\n\n                return '{' + output.join(',') + '}';\n            }\n\n            return JSON.stringify(value);\n        },\n        merge(value, params) {\n            let obj = [];\n            let arrIndex = 0;\n            let keyset = [];\n\n            // Check to see if all the objects being merged are arrays\n            if (is('Array', value)) {\n                params.forEach(param => {\n                    if (!is('Array', param)) {\n                        obj = { };\n                    }\n                });\n            } else {\n                // Create obj as an Object\n                obj = { };\n            }\n\n            if (!is('Array', obj)) {\n                obj._keys = [];\n            }\n\n            if (is('Array', value)) {\n                value.forEach(val => {\n                    if (obj._keys) {\n                        obj._keys.push(arrIndex);\n                    }\n\n                    obj[arrIndex] = val;\n                    arrIndex++;\n                });\n            } else {\n                keyset = value._keys || Object.keys(value);\n                keyset.forEach(key => {\n                    obj[key] = value[key];\n                    obj._keys.push(key);\n\n                    // Handle edge case where a number index in an object is greater than\n                    //   the array counter. In such a case, the array counter is increased\n                    //   one past the index.\n                    //\n                    // Example {{ [\"a\", \"b\"]|merge({\"4\":\"value\"}, [\"c\", \"d\"])\n                    // Without this, d would have an index of \"4\" and overwrite the value\n                    //   of \"value\"\n                    const intKey = parseInt(key, 10);\n                    if (!isNaN(intKey) && intKey >= arrIndex) {\n                        arrIndex = intKey + 1;\n                    }\n                });\n            }\n\n            // Mixin the merge arrays\n            params.forEach(param => {\n                if (is('Array', param)) {\n                    param.forEach(val => {\n                        if (obj._keys) {\n                            obj._keys.push(arrIndex);\n                        }\n\n                        obj[arrIndex] = val;\n                        arrIndex++;\n                    });\n                } else {\n                    keyset = param._keys || Object.keys(param);\n                    keyset.forEach(key => {\n                        if (!obj[key]) {\n                            obj._keys.push(key);\n                        }\n\n                        obj[key] = param[key];\n\n                        const intKey = parseInt(key, 10);\n                        if (!isNaN(intKey) && intKey >= arrIndex) {\n                            arrIndex = intKey + 1;\n                        }\n                    });\n                }\n            });\n            if (params.length === 0) {\n                throw new Twig.Error('Filter merge expects at least one parameter');\n            }\n\n            return obj;\n        },\n\n        date(value, params) {\n            const date = Twig.functions.date(value);\n            const format = params && Boolean(params.length) ? params[0] : 'F j, Y H:i';\n            return Twig.lib.date(format.replace(/\\\\\\\\/g, '\\\\'), date);\n        },\n        /* eslint-disable-next-line camelcase */\n        date_modify(value, params) {\n            if (value === undefined || value === null) {\n                return;\n            }\n\n            if (params === undefined || params.length !== 1) {\n                throw new Twig.Error('date_modify filter expects 1 argument');\n            }\n\n            const modifyText = params[0];\n            let time;\n\n            if (Twig.lib.is('Date', value)) {\n                time = Twig.lib.strtotime(modifyText, value.getTime() / 1000);\n            }\n\n            if (Twig.lib.is('String', value)) {\n                time = Twig.lib.strtotime(modifyText, Twig.lib.strtotime(value));\n            }\n\n            if (Twig.lib.is('Number', value)) {\n                time = Twig.lib.strtotime(modifyText, value);\n            }\n\n            return new Date(time * 1000);\n        },\n\n        replace(value, params) {\n            if (value === undefined || value === null) {\n                return;\n            }\n\n            const pairs = params[0];\n            let tag;\n            for (tag in pairs) {\n                if (Object.hasOwnProperty.call(pairs, tag) && tag !== '_keys') {\n                    value = Twig.lib.replaceAll(value, tag, pairs[tag]);\n                }\n            }\n\n            return value;\n        },\n\n        format(value, params) {\n            if (value === undefined || value === null) {\n                return;\n            }\n\n            return Twig.lib.vsprintf(value, params);\n        },\n\n        striptags(value, allowed) {\n            if (value === undefined || value === null) {\n                return;\n            }\n\n            return Twig.lib.stripTags(value, allowed);\n        },\n\n        escape(value, params) {\n            if (value === undefined || value === null || value === '') {\n                return;\n            }\n\n            let strategy = 'html';\n            if (params && Boolean(params.length) && params[0] !== true) {\n                strategy = params[0];\n            }\n\n            if (strategy === 'html') {\n                const rawValue = value.toString().replace(/&/g, '&amp;')\n                    .replace(/</g, '&lt;')\n                    .replace(/>/g, '&gt;')\n                    .replace(/\"/g, '&quot;')\n                    .replace(/'/g, '&#039;');\n                return new Twig.Markup(rawValue, 'html');\n            }\n\n            if (strategy === 'js') {\n                const rawValue = value.toString();\n                let result = '';\n\n                for (let i = 0; i < rawValue.length; i++) {\n                    if (rawValue[i].match(/^[a-zA-Z0-9,._]$/)) {\n                        result += rawValue[i];\n                    } else {\n                        const char = rawValue.charAt(i);\n                        const charCode = rawValue.charCodeAt(i);\n\n                        // A few characters have short escape sequences in JSON and JavaScript.\n                        // Escape sequences supported only by JavaScript, not JSON, are ommitted.\n                        // \\\" is also supported but omitted, because the resulting string is not HTML safe.\n                        const shortMap = {\n                            '\\\\': '\\\\\\\\',\n                            '/': '\\\\/',\n                            '\\u0008': '\\\\b',\n                            '\\u000C': '\\\\f',\n                            '\\u000A': '\\\\n',\n                            '\\u000D': '\\\\r',\n                            '\\u0009': '\\\\t'\n                        };\n\n                        if (shortMap[char]) {\n                            result += shortMap[char];\n                        } else {\n                            result += Twig.lib.sprintf('\\\\u%04s', charCode.toString(16).toUpperCase());\n                        }\n                    }\n                }\n\n                return new Twig.Markup(result, 'js');\n            }\n\n            if (strategy === 'css') {\n                const rawValue = value.toString();\n                let result = '';\n\n                for (let i = 0; i < rawValue.length; i++) {\n                    if (rawValue[i].match(/^[a-zA-Z0-9]$/)) {\n                        result += rawValue[i];\n                    } else {\n                        const charCode = rawValue.charCodeAt(i);\n                        result += '\\\\' + charCode.toString(16).toUpperCase() + ' ';\n                    }\n                }\n\n                return new Twig.Markup(result, 'css');\n            }\n\n            if (strategy === 'url') {\n                const result = Twig.filters.url_encode(value);\n                return new Twig.Markup(result, 'url');\n            }\n\n            if (strategy === 'html_attr') {\n                const rawValue = value.toString();\n                let result = '';\n\n                for (let i = 0; i < rawValue.length; i++) {\n                    if (rawValue[i].match(/^[a-zA-Z0-9,.\\-_]$/)) {\n                        result += rawValue[i];\n                    } else if (rawValue[i].match(/^[&<>\"]$/)) {\n                        result += rawValue[i].replace(/&/g, '&amp;')\n                            .replace(/</g, '&lt;')\n                            .replace(/>/g, '&gt;')\n                            .replace(/\"/g, '&quot;');\n                    } else {\n                        const charCode = rawValue.charCodeAt(i);\n\n                        // The following replaces characters undefined in HTML with\n                        // the hex entity for the Unicode replacement character.\n                        if (charCode <= 0x1F && charCode !== 0x09 && charCode !== 0x0A && charCode !== 0x0D) {\n                            result += '&#xFFFD;';\n                        } else if (charCode < 0x80) {\n                            result += Twig.lib.sprintf('&#x%02s;', charCode.toString(16).toUpperCase());\n                        } else {\n                            result += Twig.lib.sprintf('&#x%04s;', charCode.toString(16).toUpperCase());\n                        }\n                    }\n                }\n\n                return new Twig.Markup(result, 'html_attr');\n            }\n\n            throw new Twig.Error('escape strategy unsupported');\n        },\n\n        /* Alias of escape */\n        e(value, params) {\n            return Twig.filters.escape(value, params);\n        },\n\n        nl2br(value) {\n            if (value === undefined || value === null || value === '') {\n                return;\n            }\n\n            const linebreakTag = 'BACKSLASH_n_replace';\n            const br = '<br />' + linebreakTag;\n\n            value = Twig.filters.escape(value)\n                .replace(/\\r\\n/g, br)\n                .replace(/\\r/g, br)\n                .replace(/\\n/g, br);\n\n            value = Twig.lib.replaceAll(value, linebreakTag, '\\n');\n\n            return new Twig.Markup(value);\n        },\n\n        /**\n         * Adapted from: http://phpjs.org/functions/number_format:481\n         */\n        /* eslint-disable-next-line camelcase */\n        number_format(value, params) {\n            let number = value;\n            const decimals = (params && params[0]) ? params[0] : undefined;\n            const dec = (params && params[1] !== undefined) ? params[1] : '.';\n            const sep = (params && params[2] !== undefined) ? params[2] : ',';\n\n            number = (String(number)).replace(/[^0-9+\\-Ee.]/g, '');\n            const n = isFinite(Number(number)) ? Number(number) : 0;\n            const prec = isFinite(Number(decimals)) ? Math.abs(decimals) : 0;\n            let s = '';\n            const toFixedFix = function (n, prec) {\n                const k = 10 ** prec;\n                return String(Math.round(n * k) / k);\n            };\n\n            // Fix for IE parseFloat(0.55).toFixed(0) = 0;\n            s = (prec ? toFixedFix(n, prec) : String(Math.round(n))).split('.');\n            if (s[0].length > 3) {\n                s[0] = s[0].replace(/\\B(?=(?:\\d{3})+(?!\\d))/g, sep);\n            }\n\n            if ((s[1] || '').length < prec) {\n                s[1] = s[1] || '';\n                s[1] += new Array(prec - s[1].length + 1).join('0');\n            }\n\n            return s.join(dec);\n        },\n\n        trim(value, params) {\n            if (value === undefined || value === null) {\n                return;\n            }\n\n            let str = String(value);\n            let whitespace;\n            if (params && params[0]) {\n                whitespace = String(params[0]);\n            } else {\n                whitespace = ' \\n\\r\\t\\f\\u000B\\u00A0\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u200b\\u2028\\u2029\\u3000';\n            }\n\n            for (let i = 0; i < str.length; i++) {\n                if (!whitespace.includes(str.charAt(i))) {\n                    str = str.slice(Math.max(0, i));\n                    break;\n                }\n            }\n\n            for (let i = str.length - 1; i >= 0; i--) {\n                if (!whitespace.includes(str.charAt(i))) {\n                    str = str.slice(0, Math.max(0, i + 1));\n                    break;\n                }\n            }\n\n            return whitespace.includes(str.charAt(0)) ? '' : str;\n        },\n\n        truncate(value, params) {\n            let length = 30;\n            let preserve = false;\n            let separator = '...';\n\n            value = String(value);\n            if (params) {\n                if (params[0]) {\n                    length = params[0];\n                }\n\n                if (params[1]) {\n                    preserve = params[1];\n                }\n\n                if (params[2]) {\n                    separator = params[2];\n                }\n            }\n\n            if (value.length > length) {\n                if (preserve) {\n                    length = value.indexOf(' ', length);\n                    if (length === -1) {\n                        return value;\n                    }\n                }\n\n                value = value.slice(0, length) + separator;\n            }\n\n            return value;\n        },\n\n        slice(value, params) {\n            if (value === undefined || value === null) {\n                return;\n            }\n\n            if (params === undefined || params.length === 0) {\n                throw new Twig.Error('slice filter expects at least 1 argument');\n            }\n\n            // Default to start of string\n            const start = params[0] || 0;\n            // Default to length of string\n            const length = params.length > 1 ? params[1] : value.length;\n            // Handle negative start values\n            const startIndex = start >= 0 ? start : Math.max(value.length + start, 0);\n\n            if (Twig.lib.is('Array', value)) {\n                const output = [];\n                for (let i = startIndex; i < startIndex + length && i < value.length; i++) {\n                    output.push(value[i]);\n                }\n\n                return output;\n            }\n\n            if (Twig.lib.is('String', value)) {\n                return value.slice(startIndex, startIndex + length);\n            }\n\n            throw new Twig.Error('slice filter expects value to be an array or string');\n        },\n\n        abs(value) {\n            if (value === undefined || value === null) {\n                return;\n            }\n\n            return Math.abs(value);\n        },\n\n        first(value) {\n            if (is('Array', value)) {\n                return value[0];\n            }\n\n            if (is('Object', value)) {\n                if ('_keys' in value) {\n                    return value[value._keys[0]];\n                }\n            } else if (typeof value === 'string') {\n                return value.slice(0, 1);\n            }\n        },\n\n        split(value, params) {\n            if (value === undefined || value === null) {\n                return;\n            }\n\n            if (params === undefined || params.length === 0 || params.length > 2) {\n                throw new Twig.Error('split filter expects 1 or 2 argument');\n            }\n\n            if (Twig.lib.is('String', value)) {\n                const delimiter = params[0];\n                const limit = params[1];\n                const split = value.split(delimiter);\n\n                if (limit === undefined) {\n                    return split;\n                }\n\n                if (limit < 0) {\n                    return value.split(delimiter, split.length + limit);\n                }\n\n                const limitedSplit = [];\n\n                if (delimiter === '') {\n                    // Empty delimiter\n                    // \"aabbcc\"|split('', 2)\n                    //     -> ['aa', 'bb', 'cc']\n\n                    while (split.length > 0) {\n                        let temp = '';\n                        for (let i = 0; i < limit && split.length > 0; i++) {\n                            temp += split.shift();\n                        }\n\n                        limitedSplit.push(temp);\n                    }\n                } else {\n                    // Non-empty delimiter\n                    // \"one,two,three,four,five\"|split(',', 3)\n                    //     -> ['one', 'two', 'three,four,five']\n\n                    for (let i = 0; i < limit - 1 && split.length > 0; i++) {\n                        limitedSplit.push(split.shift());\n                    }\n\n                    if (split.length > 0) {\n                        limitedSplit.push(split.join(delimiter));\n                    }\n                }\n\n                return limitedSplit;\n            }\n\n            throw new Twig.Error('split filter expects value to be a string');\n        },\n        last(value) {\n            if (Twig.lib.is('Object', value)) {\n                let keys;\n\n                if (value._keys === undefined) {\n                    keys = Object.keys(value);\n                } else {\n                    keys = value._keys;\n                }\n\n                return value[keys[keys.length - 1]];\n            }\n\n            if (Twig.lib.is('Number', value)) {\n                return value.toString().slice(-1);\n            }\n\n            // String|array\n            return value[value.length - 1];\n        },\n        raw(value) {\n            return new Twig.Markup(value || '');\n        },\n        batch(items, params) {\n            let size = params.shift();\n            const fill = params.shift();\n            let last;\n            let missing;\n\n            if (!Twig.lib.is('Array', items)) {\n                throw new Twig.Error('batch filter expects items to be an array');\n            }\n\n            if (!Twig.lib.is('Number', size)) {\n                throw new Twig.Error('batch filter expects size to be a number');\n            }\n\n            size = Math.ceil(size);\n\n            const result = Twig.lib.chunkArray(items, size);\n\n            if (fill && items.length % size !== 0) {\n                last = result.pop();\n                missing = size - last.length;\n\n                while (missing--) {\n                    last.push(fill);\n                }\n\n                result.push(last);\n            }\n\n            return result;\n        },\n        round(value, params) {\n            params = params || [];\n\n            const precision = params.length > 0 ? params[0] : 0;\n            const method = params.length > 1 ? params[1] : 'common';\n\n            value = parseFloat(value);\n\n            if (precision && !Twig.lib.is('Number', precision)) {\n                throw new Twig.Error('round filter expects precision to be a number');\n            }\n\n            if (method === 'common') {\n                return Twig.lib.round(value, precision);\n            }\n\n            if (!Twig.lib.is('Function', Math[method])) {\n                throw new Twig.Error('round filter expects method to be \\'floor\\', \\'ceil\\', or \\'common\\'');\n            }\n\n            return Math[method](value * (10 ** precision)) / (10 ** precision);\n        },\n        spaceless(value) {\n            return value.replace(/>\\s+</g, '><').trim();\n        }\n    };\n\n    Twig.filter = function (filter, value, params) {\n        const state = this;\n\n        if (!Twig.filters[filter]) {\n            throw new Twig.Error('Unable to find filter ' + filter);\n        }\n\n        return Twig.filters[filter].call(state, value, params);\n    };\n\n    Twig.filter.extend = function (filter, definition) {\n        Twig.filters[filter] = definition;\n    };\n\n    return Twig;\n};\n","// ## twig.functions.js\n//\n// This file handles parsing filters.\nmodule.exports = function (Twig) {\n    /**\n     * @constant\n     * @type {string}\n     */\n    const TEMPLATE_NOT_FOUND_MESSAGE = 'Template \"{name}\" is not defined.';\n\n    Twig.functions = {\n        //  Attribute, block, constant, date, dump, parent, random,.\n\n        // Range function from http://phpjs.org/functions/range:499\n        // Used under an MIT License\n        range(low, high, step) {\n            // http://kevin.vanzonneveld.net\n            // +   original by: Waldo Malqui Silva\n            // *     example 1: range ( 0, 12 );\n            // *     returns 1: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]\n            // *     example 2: range( 0, 100, 10 );\n            // *     returns 2: [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]\n            // *     example 3: range( 'a', 'i' );\n            // *     returns 3: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']\n            // *     example 4: range( 'c', 'a' );\n            // *     returns 4: ['c', 'b', 'a']\n            const matrix = [];\n            let inival;\n            let endval;\n            const walker = step || 1;\n            let chars = false;\n\n            if (!isNaN(low) && !isNaN(high)) {\n                inival = parseInt(low, 10);\n                endval = parseInt(high, 10);\n            } else if (isNaN(low) && isNaN(high)) {\n                chars = true;\n                inival = low.charCodeAt(0);\n                endval = high.charCodeAt(0);\n            } else {\n                inival = (isNaN(low) ? 0 : low);\n                endval = (isNaN(high) ? 0 : high);\n            }\n\n            const plus = (!((inival > endval)));\n            if (plus) {\n                while (inival <= endval) {\n                    matrix.push(((chars) ? String.fromCharCode(inival) : inival));\n                    inival += walker;\n                }\n            } else {\n                while (inival >= endval) {\n                    matrix.push(((chars) ? String.fromCharCode(inival) : inival));\n                    inival -= walker;\n                }\n            }\n\n            return matrix;\n        },\n        cycle(arr, i) {\n            const pos = i % arr.length;\n            return arr[pos];\n        },\n        dump(...args) {\n            // Don't pass arguments to `Array.slice`, that is a performance killer\n\n            const argsCopy = [...args];\n            const state = this;\n\n            const EOL = '\\n';\n            const indentChar = '  ';\n            let indentTimes = 0;\n            let out = '';\n            const indent = function (times) {\n                let ind = '';\n                while (times > 0) {\n                    times--;\n                    ind += indentChar;\n                }\n\n                return ind;\n            };\n\n            const displayVar = function (variable) {\n                out += indent(indentTimes);\n                if (typeof (variable) === 'object') {\n                    dumpVar(variable);\n                } else if (typeof (variable) === 'function') {\n                    out += 'function()' + EOL;\n                } else if (typeof (variable) === 'string') {\n                    out += 'string(' + variable.length + ') \"' + variable + '\"' + EOL;\n                } else if (typeof (variable) === 'number') {\n                    out += 'number(' + variable + ')' + EOL;\n                } else if (typeof (variable) === 'boolean') {\n                    out += 'bool(' + variable + ')' + EOL;\n                }\n            };\n\n            const dumpVar = function (variable) {\n                let i;\n                if (variable === null) {\n                    out += 'NULL' + EOL;\n                } else if (variable === undefined) {\n                    out += 'undefined' + EOL;\n                } else if (typeof variable === 'object') {\n                    out += indent(indentTimes) + typeof (variable);\n                    indentTimes++;\n                    out += '(' + (function (obj) {\n                        let size = 0;\n                        let key;\n                        for (key in obj) {\n                            if (Object.hasOwnProperty.call(obj, key)) {\n                                size++;\n                            }\n                        }\n\n                        return size;\n                    })(variable) + ') {' + EOL;\n                    for (i in variable) {\n                        if (Object.hasOwnProperty.call(variable, i)) {\n                            out += indent(indentTimes) + '[' + i + ']=> ' + EOL;\n                            displayVar(variable[i]);\n                        }\n                    }\n\n                    indentTimes--;\n                    out += indent(indentTimes) + '}' + EOL;\n                } else {\n                    displayVar(variable);\n                }\n            };\n\n            // Handle no argument case by dumping the entire render context\n            if (argsCopy.length === 0) {\n                argsCopy.push(state.context);\n            }\n\n            argsCopy.forEach(variable => {\n                dumpVar(variable);\n            });\n\n            return out;\n        },\n        date(date) {\n            let dateObj;\n            if (date === undefined || date === null || date === '') {\n                dateObj = new Date();\n            } else if (Twig.lib.is('Date', date)) {\n                dateObj = date;\n            } else if (Twig.lib.is('String', date)) {\n                if (date.match(/^\\d+$/)) {\n                    dateObj = new Date(date * 1000);\n                } else {\n                    dateObj = new Date(Twig.lib.strtotime(date) * 1000);\n                }\n            } else if (Twig.lib.is('Number', date)) {\n                // Timestamp\n                dateObj = new Date(date * 1000);\n            } else {\n                throw new Twig.Error('Unable to parse date ' + date);\n            }\n\n            return dateObj;\n        },\n        block(blockName) {\n            const state = this;\n\n            const block = state.getBlock(blockName);\n\n            if (block !== undefined) {\n                return block.render(state, state.context);\n            }\n        },\n        parent() {\n            const state = this;\n\n            return state.getBlock(state.getNestingStackToken(Twig.logic.type.block).blockName, true).render(state, state.context);\n        },\n        attribute(object, method, params) {\n            if (Twig.lib.is('Object', object)) {\n                if (Object.hasOwnProperty.call(object, method)) {\n                    if (typeof object[method] === 'function') {\n                        return object[method].apply(undefined, params);\n                    }\n\n                    return object[method];\n                }\n            }\n\n            // Array will return element 0-index\n            return object ? (object[method] || undefined) : undefined;\n        },\n        max(values, ...args) {\n            if (Twig.lib.is('Object', values)) {\n                delete values._keys;\n                return Twig.lib.max(values);\n            }\n\n            return Reflect.apply(Twig.lib.max, null, [values, ...args]);\n        },\n        min(values, ...args) {\n            if (Twig.lib.is('Object', values)) {\n                delete values._keys;\n                return Twig.lib.min(values);\n            }\n\n            return Reflect.apply(Twig.lib.min, null, [values, ...args]);\n        },\n        /* eslint-disable-next-line camelcase */\n        template_from_string(template) {\n            const state = this;\n\n            if (template === undefined) {\n                template = '';\n            }\n\n            return Twig.Templates.parsers.twig({\n                options: state.template.options,\n                data: template\n            });\n        },\n        random(value) {\n            const LIMIT_INT31 = 0x80000000;\n\n            function getRandomNumber(n) {\n                const random = Math.floor(Math.random() * LIMIT_INT31);\n                const min = Math.min.call(null, 0, n);\n                const max = Math.max.call(null, 0, n);\n                return min + Math.floor((max - min + 1) * random / LIMIT_INT31);\n            }\n\n            if (Twig.lib.is('Number', value)) {\n                return getRandomNumber(value);\n            }\n\n            if (Twig.lib.is('String', value)) {\n                return value.charAt(getRandomNumber(value.length - 1));\n            }\n\n            if (Twig.lib.is('Array', value)) {\n                return value[getRandomNumber(value.length - 1)];\n            }\n\n            if (Twig.lib.is('Object', value)) {\n                const keys = Object.keys(value);\n                return value[keys[getRandomNumber(keys.length - 1)]];\n            }\n\n            return getRandomNumber(LIMIT_INT31 - 1);\n        },\n\n        /**\n         * Returns the content of a template without rendering it\n         * @param {string} name\n         * @param {boolean} [ignoreMissing=false]\n         * @returns {string}\n         */\n        source(name, ignoreMissing) {\n            let templateSource;\n            let templateFound = false;\n            const isNodeEnvironment = typeof module !== 'undefined' && typeof module.exports !== 'undefined' && typeof window === 'undefined';\n            let loader;\n            const path = name;\n\n            // If we are running in a node.js environment, set the loader to 'fs'.\n            if (isNodeEnvironment) {\n                loader = 'fs';\n            } else {\n                loader = 'ajax';\n            }\n\n            // Build the params object\n            const params = {\n                id: name,\n                path,\n                method: loader,\n                parser: 'source',\n                async: false,\n                fetchTemplateSource: true\n            };\n\n            // Default ignoreMissing to false\n            if (typeof ignoreMissing === 'undefined') {\n                ignoreMissing = false;\n            }\n\n            // Try to load the remote template\n            //\n            // on exception, log it\n            try {\n                templateSource = Twig.Templates.loadRemote(name, params);\n\n                // If the template is undefined or null, set the template to an empty string and do NOT flip the\n                // boolean indicating we found the template\n                //\n                // else, all is good! flip the boolean indicating we found the template\n                if (typeof templateSource === 'undefined' || templateSource === null) {\n                    templateSource = '';\n                } else {\n                    templateFound = true;\n                }\n            } catch (error) {\n                Twig.log.debug('Twig.functions.source: ', 'Problem loading template  ', error);\n            }\n\n            // If the template was NOT found AND we are not ignoring missing templates, return the same message\n            // that is returned by the PHP implementation of the twig source() function\n            //\n            // else, return the template source\n            if (!templateFound && !ignoreMissing) {\n                return TEMPLATE_NOT_FOUND_MESSAGE.replace('{name}', name);\n            }\n\n            return templateSource;\n        }\n    };\n\n    Twig._function = function (_function, value, params) {\n        if (!Twig.functions[_function]) {\n            throw new Twig.Error('Unable to find function ' + _function);\n        }\n\n        return Twig.functions[_function](value, params);\n    };\n\n    Twig._function.extend = function (_function, definition) {\n        Twig.functions[_function] = definition;\n    };\n\n    return Twig;\n};\n","// ## twig.lib.js\n//\n// This file contains 3rd party libraries used within twig.\n//\n// Copies of the licenses for the code included here can be found in the\n// LICENSES.md file.\n//\n\nmodule.exports = function (Twig) {\n    // Namespace for libraries\n    Twig.lib = { };\n\n    Twig.lib.sprintf = require('locutus/php/strings/sprintf');\n    Twig.lib.vsprintf = require('locutus/php/strings/vsprintf');\n    Twig.lib.round = require('locutus/php/math/round');\n    Twig.lib.max = require('locutus/php/math/max');\n    Twig.lib.min = require('locutus/php/math/min');\n    Twig.lib.stripTags = require('locutus/php/strings/strip_tags');\n    Twig.lib.strtotime = require('locutus/php/datetime/strtotime');\n    Twig.lib.date = require('locutus/php/datetime/date');\n    Twig.lib.boolval = require('locutus/php/var/boolval');\n\n    Twig.lib.is = function (type, obj) {\n        if (typeof obj === 'undefined' || obj === null) {\n            return false;\n        }\n\n        switch (type) {\n            case 'Array':\n                return Array.isArray(obj);\n            case 'Date':\n                return obj instanceof Date;\n            case 'String':\n                return (typeof obj === 'string' || obj instanceof String);\n            case 'Number':\n                return (typeof obj === 'number' || obj instanceof Number);\n            case 'Function':\n                return (typeof obj === 'function');\n            case 'Object':\n                return obj instanceof Object;\n            default:\n                return false;\n        }\n    };\n\n    Twig.lib.replaceAll = function (string, search, replace) {\n        // Escape possible regular expression syntax\n        const searchEscaped = search.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n\n        return string.replace(new RegExp(searchEscaped, 'g'), replace);\n    };\n\n    // Chunk an array (arr) into arrays of (size) items, returns an array of arrays, or an empty array on invalid input\n    Twig.lib.chunkArray = function (arr, size) {\n        const returnVal = [];\n        let x = 0;\n        const len = arr.length;\n\n        if (size < 1 || !Array.isArray(arr)) {\n            return [];\n        }\n\n        while (x < len) {\n            returnVal.push(arr.slice(x, x += size));\n        }\n\n        return returnVal;\n    };\n\n    return Twig;\n};\n","'use strict';\n\nmodule.exports = function vsprintf(format, args) {\n  //  discuss at: https://locutus.io/php/vsprintf/\n  // original by: ejsanders\n  //   example 1: vsprintf('%04d-%02d-%02d', [1988, 8, 1])\n  //   returns 1: '1988-08-01'\n\n  var sprintf = require('../strings/sprintf');\n\n  return sprintf.apply(this, [format].concat(args));\n};\n//# sourceMappingURL=vsprintf.js.map","'use strict';\n\nfunction roundToInt(value, mode) {\n  var tmp = Math.floor(Math.abs(value) + 0.5);\n\n  if (mode === 'PHP_ROUND_HALF_DOWN' && value === tmp - 0.5 || mode === 'PHP_ROUND_HALF_EVEN' && value === 0.5 + 2 * Math.floor(tmp / 2) || mode === 'PHP_ROUND_HALF_ODD' && value === 0.5 + 2 * Math.floor(tmp / 2) - 1) {\n    tmp -= 1;\n  }\n\n  return value < 0 ? -tmp : tmp;\n}\n\nmodule.exports = function round(value) {\n  var precision = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n  var mode = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'PHP_ROUND_HALF_UP';\n\n  //  discuss at: https://locutus.io/php/round/\n  // original by: Philip Peterson\n  //  revised by: Onno Marsman (https://twitter.com/onnomarsman)\n  //  revised by: T.Wild\n  //  revised by: Rafał Kukawski (https://blog.kukawski.pl)\n  //    input by: Greenseed\n  //    input by: meo\n  //    input by: William\n  //    input by: Josep Sanz (https://www.ws3.es/)\n  // bugfixed by: Brett Zamir (https://brett-zamir.me)\n  //  revised by: Rafał Kukawski\n  //   example 1: round(1241757, -3)\n  //   returns 1: 1242000\n  //   example 2: round(3.6)\n  //   returns 2: 4\n  //   example 3: round(2.835, 2)\n  //   returns 3: 2.84\n  //   example 4: round(1.1749999999999, 2)\n  //   returns 4: 1.17\n  //   example 5: round(58551.799999999996, 2)\n  //   returns 5: 58551.8\n  //   example 6: round(4096.485, 2)\n  //   returns 6: 4096.49\n\n  var floatCast = require('../_helpers/_php_cast_float');\n  var intCast = require('../_helpers/_php_cast_int');\n  var p;\n\n  // the code is heavily based on the native PHP implementation\n  // https://github.com/php/php-src/blob/PHP-7.4/ext/standard/math.c#L355\n\n  value = floatCast(value);\n  precision = intCast(precision);\n  p = Math.pow(10, precision);\n\n  if (isNaN(value) || !isFinite(value)) {\n    return value;\n  }\n\n  // if value already integer and positive precision\n  // then nothing to do, return early\n  if (Math.trunc(value) === value && precision >= 0) {\n    return value;\n  }\n\n  // PHP does a pre-rounding before rounding to desired precision\n  // https://wiki.php.net/rfc/rounding#pre-rounding_to_the_value_s_precision_if_possible\n  var preRoundPrecision = 14 - Math.floor(Math.log10(Math.abs(value)));\n\n  if (preRoundPrecision > precision && preRoundPrecision - 15 < precision) {\n    value = roundToInt(value * Math.pow(10, preRoundPrecision), mode);\n    value /= Math.pow(10, Math.abs(precision - preRoundPrecision));\n  } else {\n    value *= p;\n  }\n\n  value = roundToInt(value, mode);\n\n  return value / p;\n};\n//# sourceMappingURL=round.js.map","'use strict';\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nmodule.exports = function _php_cast_float(value) {\n  // eslint-disable-line camelcase\n  // original by: Rafał Kukawski\n  //   example 1: _php_cast_float(false)\n  //   returns 1: 0\n  //   example 2: _php_cast_float(true)\n  //   returns 2: 1\n  //   example 3: _php_cast_float(0)\n  //   returns 3: 0\n  //   example 4: _php_cast_float(1)\n  //   returns 4: 1\n  //   example 5: _php_cast_float(3.14)\n  //   returns 5: 3.14\n  //   example 6: _php_cast_float('')\n  //   returns 6: 0\n  //   example 7: _php_cast_float('0')\n  //   returns 7: 0\n  //   example 8: _php_cast_float('abc')\n  //   returns 8: 0\n  //   example 9: _php_cast_float(null)\n  //   returns 9: 0\n  //  example 10: _php_cast_float(undefined)\n  //  returns 10: 0\n  //  example 11: _php_cast_float('123abc')\n  //  returns 11: 123\n  //  example 12: _php_cast_float('123e4')\n  //  returns 12: 1230000\n  //  example 13: _php_cast_float(0x200000001)\n  //  returns 13: 8589934593\n  //  example 14: _php_cast_float('3.14abc')\n  //  returns 14: 3.14\n\n  var type = typeof value === 'undefined' ? 'undefined' : _typeof(value);\n\n  switch (type) {\n    case 'number':\n      return value;\n    case 'string':\n      return parseFloat(value) || 0;\n    case 'boolean':\n    // fall through\n    default:\n      // PHP docs state, that for types other than string\n      // conversion is {input type}->int->float\n      return require('./_php_cast_int')(value);\n  }\n};\n//# sourceMappingURL=_php_cast_float.js.map","'use strict';\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nmodule.exports = function max() {\n  //  discuss at: https://locutus.io/php/max/\n  // original by: Onno Marsman (https://twitter.com/onnomarsman)\n  //  revised by: Onno Marsman (https://twitter.com/onnomarsman)\n  // improved by: Jack\n  //      note 1: Long code cause we're aiming for maximum PHP compatibility\n  //   example 1: max(1, 3, 5, 6, 7)\n  //   returns 1: 7\n  //   example 2: max([2, 4, 5])\n  //   returns 2: 5\n  //   example 3: max(0, 'hello')\n  //   returns 3: 0\n  //   example 4: max('hello', 0)\n  //   returns 4: 'hello'\n  //   example 5: max(-1, 'hello')\n  //   returns 5: 'hello'\n  //   example 6: max([2, 4, 8], [2, 5, 7])\n  //   returns 6: [2, 5, 7]\n\n  var ar;\n  var retVal;\n  var i = 0;\n  var n = 0;\n  var argv = arguments;\n  var argc = argv.length;\n  var _obj2Array = function _obj2Array(obj) {\n    if (Object.prototype.toString.call(obj) === '[object Array]') {\n      return obj;\n    } else {\n      var ar = [];\n      for (var i in obj) {\n        if (obj.hasOwnProperty(i)) {\n          ar.push(obj[i]);\n        }\n      }\n      return ar;\n    }\n  };\n  var _compare = function _compare(current, next) {\n    var i = 0;\n    var n = 0;\n    var tmp = 0;\n    var nl = 0;\n    var cl = 0;\n\n    if (current === next) {\n      return 0;\n    } else if ((typeof current === 'undefined' ? 'undefined' : _typeof(current)) === 'object') {\n      if ((typeof next === 'undefined' ? 'undefined' : _typeof(next)) === 'object') {\n        current = _obj2Array(current);\n        next = _obj2Array(next);\n        cl = current.length;\n        nl = next.length;\n        if (nl > cl) {\n          return 1;\n        } else if (nl < cl) {\n          return -1;\n        }\n        for (i = 0, n = cl; i < n; ++i) {\n          tmp = _compare(current[i], next[i]);\n          if (tmp === 1) {\n            return 1;\n          } else if (tmp === -1) {\n            return -1;\n          }\n        }\n        return 0;\n      }\n      return -1;\n    } else if ((typeof next === 'undefined' ? 'undefined' : _typeof(next)) === 'object') {\n      return 1;\n    } else if (isNaN(next) && !isNaN(current)) {\n      if (current === 0) {\n        return 0;\n      }\n      return current < 0 ? 1 : -1;\n    } else if (isNaN(current) && !isNaN(next)) {\n      if (next === 0) {\n        return 0;\n      }\n      return next > 0 ? 1 : -1;\n    }\n\n    if (next === current) {\n      return 0;\n    }\n\n    return next > current ? 1 : -1;\n  };\n\n  if (argc === 0) {\n    throw new Error('At least one value should be passed to max()');\n  } else if (argc === 1) {\n    if (_typeof(argv[0]) === 'object') {\n      ar = _obj2Array(argv[0]);\n    } else {\n      throw new Error('Wrong parameter count for max()');\n    }\n    if (ar.length === 0) {\n      throw new Error('Array must contain at least one element for max()');\n    }\n  } else {\n    ar = argv;\n  }\n\n  retVal = ar[0];\n  for (i = 1, n = ar.length; i < n; ++i) {\n    if (_compare(retVal, ar[i]) === 1) {\n      retVal = ar[i];\n    }\n  }\n\n  return retVal;\n};\n//# sourceMappingURL=max.js.map","'use strict';\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nmodule.exports = function min() {\n  //  discuss at: https://locutus.io/php/min/\n  // original by: Onno Marsman (https://twitter.com/onnomarsman)\n  //  revised by: Onno Marsman (https://twitter.com/onnomarsman)\n  // improved by: Jack\n  //      note 1: Long code cause we're aiming for maximum PHP compatibility\n  //   example 1: min(1, 3, 5, 6, 7)\n  //   returns 1: 1\n  //   example 2: min([2, 4, 5])\n  //   returns 2: 2\n  //   example 3: min(0, 'hello')\n  //   returns 3: 0\n  //   example 4: min('hello', 0)\n  //   returns 4: 'hello'\n  //   example 5: min(-1, 'hello')\n  //   returns 5: -1\n  //   example 6: min([2, 4, 8], [2, 5, 7])\n  //   returns 6: [2, 4, 8]\n\n  var ar;\n  var retVal;\n  var i = 0;\n  var n = 0;\n  var argv = arguments;\n  var argc = argv.length;\n  var _obj2Array = function _obj2Array(obj) {\n    if (Object.prototype.toString.call(obj) === '[object Array]') {\n      return obj;\n    }\n    var ar = [];\n    for (var i in obj) {\n      if (obj.hasOwnProperty(i)) {\n        ar.push(obj[i]);\n      }\n    }\n    return ar;\n  };\n\n  var _compare = function _compare(current, next) {\n    var i = 0;\n    var n = 0;\n    var tmp = 0;\n    var nl = 0;\n    var cl = 0;\n\n    if (current === next) {\n      return 0;\n    } else if ((typeof current === 'undefined' ? 'undefined' : _typeof(current)) === 'object') {\n      if ((typeof next === 'undefined' ? 'undefined' : _typeof(next)) === 'object') {\n        current = _obj2Array(current);\n        next = _obj2Array(next);\n        cl = current.length;\n        nl = next.length;\n        if (nl > cl) {\n          return 1;\n        } else if (nl < cl) {\n          return -1;\n        }\n        for (i = 0, n = cl; i < n; ++i) {\n          tmp = _compare(current[i], next[i]);\n          if (tmp === 1) {\n            return 1;\n          } else if (tmp === -1) {\n            return -1;\n          }\n        }\n        return 0;\n      }\n      return -1;\n    } else if ((typeof next === 'undefined' ? 'undefined' : _typeof(next)) === 'object') {\n      return 1;\n    } else if (isNaN(next) && !isNaN(current)) {\n      if (current === 0) {\n        return 0;\n      }\n      return current < 0 ? 1 : -1;\n    } else if (isNaN(current) && !isNaN(next)) {\n      if (next === 0) {\n        return 0;\n      }\n      return next > 0 ? 1 : -1;\n    }\n\n    if (next === current) {\n      return 0;\n    }\n\n    return next > current ? 1 : -1;\n  };\n\n  if (argc === 0) {\n    throw new Error('At least one value should be passed to min()');\n  } else if (argc === 1) {\n    if (_typeof(argv[0]) === 'object') {\n      ar = _obj2Array(argv[0]);\n    } else {\n      throw new Error('Wrong parameter count for min()');\n    }\n\n    if (ar.length === 0) {\n      throw new Error('Array must contain at least one element for min()');\n    }\n  } else {\n    ar = argv;\n  }\n\n  retVal = ar[0];\n\n  for (i = 1, n = ar.length; i < n; ++i) {\n    if (_compare(retVal, ar[i]) === -1) {\n      retVal = ar[i];\n    }\n  }\n\n  return retVal;\n};\n//# sourceMappingURL=min.js.map","'use strict';\n\nmodule.exports = function strip_tags(input, allowed) {\n  // eslint-disable-line camelcase\n  //  discuss at: https://locutus.io/php/strip_tags/\n  // original by: Kevin van Zonneveld (https://kvz.io)\n  // improved by: Luke Godfrey\n  // improved by: Kevin van Zonneveld (https://kvz.io)\n  //    input by: Pul\n  //    input by: Alex\n  //    input by: Marc Palau\n  //    input by: Brett Zamir (https://brett-zamir.me)\n  //    input by: Bobby Drake\n  //    input by: Evertjan Garretsen\n  // bugfixed by: Kevin van Zonneveld (https://kvz.io)\n  // bugfixed by: Onno Marsman (https://twitter.com/onnomarsman)\n  // bugfixed by: Kevin van Zonneveld (https://kvz.io)\n  // bugfixed by: Kevin van Zonneveld (https://kvz.io)\n  // bugfixed by: Eric Nagel\n  // bugfixed by: Kevin van Zonneveld (https://kvz.io)\n  // bugfixed by: Tomasz Wesolowski\n  // bugfixed by: Tymon Sturgeon (https://scryptonite.com)\n  // bugfixed by: Tim de Koning (https://www.kingsquare.nl)\n  //  revised by: Rafał Kukawski (https://blog.kukawski.pl)\n  //   example 1: strip_tags('<p>Kevin</p> <br /><b>van</b> <i>Zonneveld</i>', '<i><b>')\n  //   returns 1: 'Kevin <b>van</b> <i>Zonneveld</i>'\n  //   example 2: strip_tags('<p>Kevin <img src=\"someimage.png\" onmouseover=\"someFunction()\">van <i>Zonneveld</i></p>', '<p>')\n  //   returns 2: '<p>Kevin van Zonneveld</p>'\n  //   example 3: strip_tags(\"<a href='https://kvz.io'>Kevin van Zonneveld</a>\", \"<a>\")\n  //   returns 3: \"<a href='https://kvz.io'>Kevin van Zonneveld</a>\"\n  //   example 4: strip_tags('1 < 5 5 > 1')\n  //   returns 4: '1 < 5 5 > 1'\n  //   example 5: strip_tags('1 <br/> 1')\n  //   returns 5: '1  1'\n  //   example 6: strip_tags('1 <br/> 1', '<br>')\n  //   returns 6: '1 <br/> 1'\n  //   example 7: strip_tags('1 <br/> 1', '<br><br/>')\n  //   returns 7: '1 <br/> 1'\n  //   example 8: strip_tags('<i>hello</i> <<foo>script>world<</foo>/script>')\n  //   returns 8: 'hello world'\n  //   example 9: strip_tags(4)\n  //   returns 9: '4'\n\n  var _phpCastString = require('../_helpers/_phpCastString');\n\n  // making sure the allowed arg is a string containing only tags in lowercase (<a><b><c>)\n  allowed = (((allowed || '') + '').toLowerCase().match(/<[a-z][a-z0-9]*>/g) || []).join('');\n\n  var tags = /<\\/?([a-z0-9]*)\\b[^>]*>?/gi;\n  var commentsAndPhpTags = /<!--[\\s\\S]*?-->|<\\?(?:php)?[\\s\\S]*?\\?>/gi;\n\n  var after = _phpCastString(input);\n  // removes tha '<' char at the end of the string to replicate PHP's behaviour\n  after = after.substring(after.length - 1) === '<' ? after.substring(0, after.length - 1) : after;\n\n  // recursively remove tags to ensure that the returned string doesn't contain forbidden tags after previous passes (e.g. '<<bait/>switch/>')\n  while (true) {\n    var before = after;\n    after = before.replace(commentsAndPhpTags, '').replace(tags, function ($0, $1) {\n      return allowed.indexOf('<' + $1.toLowerCase() + '>') > -1 ? $0 : '';\n    });\n\n    // return once no more tags are removed\n    if (before === after) {\n      return after;\n    }\n  }\n};\n//# sourceMappingURL=strip_tags.js.map","'use strict';\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nmodule.exports = function _phpCastString(value) {\n  // original by: Rafał Kukawski\n  //   example 1: _phpCastString(true)\n  //   returns 1: '1'\n  //   example 2: _phpCastString(false)\n  //   returns 2: ''\n  //   example 3: _phpCastString('foo')\n  //   returns 3: 'foo'\n  //   example 4: _phpCastString(0/0)\n  //   returns 4: 'NAN'\n  //   example 5: _phpCastString(1/0)\n  //   returns 5: 'INF'\n  //   example 6: _phpCastString(-1/0)\n  //   returns 6: '-INF'\n  //   example 7: _phpCastString(null)\n  //   returns 7: ''\n  //   example 8: _phpCastString(undefined)\n  //   returns 8: ''\n  //   example 9: _phpCastString([])\n  //   returns 9: 'Array'\n  //   example 10: _phpCastString({})\n  //   returns 10: 'Object'\n  //   example 11: _phpCastString(0)\n  //   returns 11: '0'\n  //   example 12: _phpCastString(1)\n  //   returns 12: '1'\n  //   example 13: _phpCastString(3.14)\n  //   returns 13: '3.14'\n\n  var type = typeof value === 'undefined' ? 'undefined' : _typeof(value);\n\n  switch (type) {\n    case 'boolean':\n      return value ? '1' : '';\n    case 'string':\n      return value;\n    case 'number':\n      if (isNaN(value)) {\n        return 'NAN';\n      }\n\n      if (!isFinite(value)) {\n        return (value < 0 ? '-' : '') + 'INF';\n      }\n\n      return value + '';\n    case 'undefined':\n      return '';\n    case 'object':\n      if (Array.isArray(value)) {\n        return 'Array';\n      }\n\n      if (value !== null) {\n        return 'Object';\n      }\n\n      return '';\n    case 'function':\n    // fall through\n    default:\n      throw new Error('Unsupported value type');\n  }\n};\n//# sourceMappingURL=_phpCastString.js.map","'use strict';\n\nvar reSpace = '[ \\\\t]+';\nvar reSpaceOpt = '[ \\\\t]*';\nvar reMeridian = '(?:([ap])\\\\.?m\\\\.?([\\\\t ]|$))';\nvar reHour24 = '(2[0-4]|[01]?[0-9])';\nvar reHour24lz = '([01][0-9]|2[0-4])';\nvar reHour12 = '(0?[1-9]|1[0-2])';\nvar reMinute = '([0-5]?[0-9])';\nvar reMinutelz = '([0-5][0-9])';\nvar reSecond = '(60|[0-5]?[0-9])';\nvar reSecondlz = '(60|[0-5][0-9])';\nvar reFrac = '(?:\\\\.([0-9]+))';\n\nvar reDayfull = 'sunday|monday|tuesday|wednesday|thursday|friday|saturday';\nvar reDayabbr = 'sun|mon|tue|wed|thu|fri|sat';\nvar reDaytext = reDayfull + '|' + reDayabbr + '|weekdays?';\n\nvar reReltextnumber = 'first|second|third|fourth|fifth|sixth|seventh|eighth?|ninth|tenth|eleventh|twelfth';\nvar reReltexttext = 'next|last|previous|this';\nvar reReltextunit = '(?:second|sec|minute|min|hour|day|fortnight|forthnight|month|year)s?|weeks|' + reDaytext;\n\nvar reYear = '([0-9]{1,4})';\nvar reYear2 = '([0-9]{2})';\nvar reYear4 = '([0-9]{4})';\nvar reYear4withSign = '([+-]?[0-9]{4})';\nvar reMonth = '(1[0-2]|0?[0-9])';\nvar reMonthlz = '(0[0-9]|1[0-2])';\nvar reDay = '(?:(3[01]|[0-2]?[0-9])(?:st|nd|rd|th)?)';\nvar reDaylz = '(0[0-9]|[1-2][0-9]|3[01])';\n\nvar reMonthFull = 'january|february|march|april|may|june|july|august|september|october|november|december';\nvar reMonthAbbr = 'jan|feb|mar|apr|may|jun|jul|aug|sept?|oct|nov|dec';\nvar reMonthroman = 'i[vx]|vi{0,3}|xi{0,2}|i{1,3}';\nvar reMonthText = '(' + reMonthFull + '|' + reMonthAbbr + '|' + reMonthroman + ')';\n\nvar reTzCorrection = '((?:GMT)?([+-])' + reHour24 + ':?' + reMinute + '?)';\nvar reDayOfYear = '(00[1-9]|0[1-9][0-9]|[12][0-9][0-9]|3[0-5][0-9]|36[0-6])';\nvar reWeekOfYear = '(0[1-9]|[1-4][0-9]|5[0-3])';\n\nvar reDateNoYear = reMonthText + '[ .\\\\t-]*' + reDay + '[,.stndrh\\\\t ]*';\n\nfunction processMeridian(hour, meridian) {\n  meridian = meridian && meridian.toLowerCase();\n\n  switch (meridian) {\n    case 'a':\n      hour += hour === 12 ? -12 : 0;\n      break;\n    case 'p':\n      hour += hour !== 12 ? 12 : 0;\n      break;\n  }\n\n  return hour;\n}\n\nfunction processYear(yearStr) {\n  var year = +yearStr;\n\n  if (yearStr.length < 4 && year < 100) {\n    year += year < 70 ? 2000 : 1900;\n  }\n\n  return year;\n}\n\nfunction lookupMonth(monthStr) {\n  return {\n    jan: 0,\n    january: 0,\n    i: 0,\n    feb: 1,\n    february: 1,\n    ii: 1,\n    mar: 2,\n    march: 2,\n    iii: 2,\n    apr: 3,\n    april: 3,\n    iv: 3,\n    may: 4,\n    v: 4,\n    jun: 5,\n    june: 5,\n    vi: 5,\n    jul: 6,\n    july: 6,\n    vii: 6,\n    aug: 7,\n    august: 7,\n    viii: 7,\n    sep: 8,\n    sept: 8,\n    september: 8,\n    ix: 8,\n    oct: 9,\n    october: 9,\n    x: 9,\n    nov: 10,\n    november: 10,\n    xi: 10,\n    dec: 11,\n    december: 11,\n    xii: 11\n  }[monthStr.toLowerCase()];\n}\n\nfunction lookupWeekday(dayStr) {\n  var desiredSundayNumber = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n\n  var dayNumbers = {\n    mon: 1,\n    monday: 1,\n    tue: 2,\n    tuesday: 2,\n    wed: 3,\n    wednesday: 3,\n    thu: 4,\n    thursday: 4,\n    fri: 5,\n    friday: 5,\n    sat: 6,\n    saturday: 6,\n    sun: 0,\n    sunday: 0\n  };\n\n  return dayNumbers[dayStr.toLowerCase()] || desiredSundayNumber;\n}\n\nfunction lookupRelative(relText) {\n  var relativeNumbers = {\n    last: -1,\n    previous: -1,\n    this: 0,\n    first: 1,\n    next: 1,\n    second: 2,\n    third: 3,\n    fourth: 4,\n    fifth: 5,\n    sixth: 6,\n    seventh: 7,\n    eight: 8,\n    eighth: 8,\n    ninth: 9,\n    tenth: 10,\n    eleventh: 11,\n    twelfth: 12\n  };\n\n  var relativeBehavior = {\n    this: 1\n  };\n\n  var relTextLower = relText.toLowerCase();\n\n  return {\n    amount: relativeNumbers[relTextLower],\n    behavior: relativeBehavior[relTextLower] || 0\n  };\n}\n\nfunction processTzCorrection(tzOffset, oldValue) {\n  var reTzCorrectionLoose = /(?:GMT)?([+-])(\\d+)(:?)(\\d{0,2})/i;\n  tzOffset = tzOffset && tzOffset.match(reTzCorrectionLoose);\n\n  if (!tzOffset) {\n    return oldValue;\n  }\n\n  var sign = tzOffset[1] === '-' ? 1 : -1;\n  var hours = +tzOffset[2];\n  var minutes = +tzOffset[4];\n\n  if (!tzOffset[4] && !tzOffset[3]) {\n    minutes = Math.floor(hours % 100);\n    hours = Math.floor(hours / 100);\n  }\n\n  return sign * (hours * 60 + minutes);\n}\n\nvar formats = {\n  yesterday: {\n    regex: /^yesterday/i,\n    name: 'yesterday',\n    callback: function callback() {\n      this.rd -= 1;\n      return this.resetTime();\n    }\n  },\n\n  now: {\n    regex: /^now/i,\n    name: 'now'\n    // do nothing\n  },\n\n  noon: {\n    regex: /^noon/i,\n    name: 'noon',\n    callback: function callback() {\n      return this.resetTime() && this.time(12, 0, 0, 0);\n    }\n  },\n\n  midnightOrToday: {\n    regex: /^(midnight|today)/i,\n    name: 'midnight | today',\n    callback: function callback() {\n      return this.resetTime();\n    }\n  },\n\n  tomorrow: {\n    regex: /^tomorrow/i,\n    name: 'tomorrow',\n    callback: function callback() {\n      this.rd += 1;\n      return this.resetTime();\n    }\n  },\n\n  timestamp: {\n    regex: /^@(-?\\d+)/i,\n    name: 'timestamp',\n    callback: function callback(match, timestamp) {\n      this.rs += +timestamp;\n      this.y = 1970;\n      this.m = 0;\n      this.d = 1;\n      this.dates = 0;\n\n      return this.resetTime() && this.zone(0);\n    }\n  },\n\n  firstOrLastDay: {\n    regex: /^(first|last) day of/i,\n    name: 'firstdayof | lastdayof',\n    callback: function callback(match, day) {\n      if (day.toLowerCase() === 'first') {\n        this.firstOrLastDayOfMonth = 1;\n      } else {\n        this.firstOrLastDayOfMonth = -1;\n      }\n    }\n  },\n\n  backOrFrontOf: {\n    regex: RegExp('^(back|front) of ' + reHour24 + reSpaceOpt + reMeridian + '?', 'i'),\n    name: 'backof | frontof',\n    callback: function callback(match, side, hours, meridian) {\n      var back = side.toLowerCase() === 'back';\n      var hour = +hours;\n      var minute = 15;\n\n      if (!back) {\n        hour -= 1;\n        minute = 45;\n      }\n\n      hour = processMeridian(hour, meridian);\n\n      return this.resetTime() && this.time(hour, minute, 0, 0);\n    }\n  },\n\n  weekdayOf: {\n    regex: RegExp('^(' + reReltextnumber + '|' + reReltexttext + ')' + reSpace + '(' + reDayfull + '|' + reDayabbr + ')' + reSpace + 'of', 'i'),\n    name: 'weekdayof'\n    // todo\n  },\n\n  mssqltime: {\n    regex: RegExp('^' + reHour12 + ':' + reMinutelz + ':' + reSecondlz + '[:.]([0-9]+)' + reMeridian, 'i'),\n    name: 'mssqltime',\n    callback: function callback(match, hour, minute, second, frac, meridian) {\n      return this.time(processMeridian(+hour, meridian), +minute, +second, +frac.substr(0, 3));\n    }\n  },\n\n  timeLong12: {\n    regex: RegExp('^' + reHour12 + '[:.]' + reMinute + '[:.]' + reSecondlz + reSpaceOpt + reMeridian, 'i'),\n    name: 'timelong12',\n    callback: function callback(match, hour, minute, second, meridian) {\n      return this.time(processMeridian(+hour, meridian), +minute, +second, 0);\n    }\n  },\n\n  timeShort12: {\n    regex: RegExp('^' + reHour12 + '[:.]' + reMinutelz + reSpaceOpt + reMeridian, 'i'),\n    name: 'timeshort12',\n    callback: function callback(match, hour, minute, meridian) {\n      return this.time(processMeridian(+hour, meridian), +minute, 0, 0);\n    }\n  },\n\n  timeTiny12: {\n    regex: RegExp('^' + reHour12 + reSpaceOpt + reMeridian, 'i'),\n    name: 'timetiny12',\n    callback: function callback(match, hour, meridian) {\n      return this.time(processMeridian(+hour, meridian), 0, 0, 0);\n    }\n  },\n\n  soap: {\n    regex: RegExp('^' + reYear4 + '-' + reMonthlz + '-' + reDaylz + 'T' + reHour24lz + ':' + reMinutelz + ':' + reSecondlz + reFrac + reTzCorrection + '?', 'i'),\n    name: 'soap',\n    callback: function callback(match, year, month, day, hour, minute, second, frac, tzCorrection) {\n      return this.ymd(+year, month - 1, +day) && this.time(+hour, +minute, +second, +frac.substr(0, 3)) && this.zone(processTzCorrection(tzCorrection));\n    }\n  },\n\n  wddx: {\n    regex: RegExp('^' + reYear4 + '-' + reMonth + '-' + reDay + 'T' + reHour24 + ':' + reMinute + ':' + reSecond),\n    name: 'wddx',\n    callback: function callback(match, year, month, day, hour, minute, second) {\n      return this.ymd(+year, month - 1, +day) && this.time(+hour, +minute, +second, 0);\n    }\n  },\n\n  exif: {\n    regex: RegExp('^' + reYear4 + ':' + reMonthlz + ':' + reDaylz + ' ' + reHour24lz + ':' + reMinutelz + ':' + reSecondlz, 'i'),\n    name: 'exif',\n    callback: function callback(match, year, month, day, hour, minute, second) {\n      return this.ymd(+year, month - 1, +day) && this.time(+hour, +minute, +second, 0);\n    }\n  },\n\n  xmlRpc: {\n    regex: RegExp('^' + reYear4 + reMonthlz + reDaylz + 'T' + reHour24 + ':' + reMinutelz + ':' + reSecondlz),\n    name: 'xmlrpc',\n    callback: function callback(match, year, month, day, hour, minute, second) {\n      return this.ymd(+year, month - 1, +day) && this.time(+hour, +minute, +second, 0);\n    }\n  },\n\n  xmlRpcNoColon: {\n    regex: RegExp('^' + reYear4 + reMonthlz + reDaylz + '[Tt]' + reHour24 + reMinutelz + reSecondlz),\n    name: 'xmlrpcnocolon',\n    callback: function callback(match, year, month, day, hour, minute, second) {\n      return this.ymd(+year, month - 1, +day) && this.time(+hour, +minute, +second, 0);\n    }\n  },\n\n  clf: {\n    regex: RegExp('^' + reDay + '/(' + reMonthAbbr + ')/' + reYear4 + ':' + reHour24lz + ':' + reMinutelz + ':' + reSecondlz + reSpace + reTzCorrection, 'i'),\n    name: 'clf',\n    callback: function callback(match, day, month, year, hour, minute, second, tzCorrection) {\n      return this.ymd(+year, lookupMonth(month), +day) && this.time(+hour, +minute, +second, 0) && this.zone(processTzCorrection(tzCorrection));\n    }\n  },\n\n  iso8601long: {\n    regex: RegExp('^t?' + reHour24 + '[:.]' + reMinute + '[:.]' + reSecond + reFrac, 'i'),\n    name: 'iso8601long',\n    callback: function callback(match, hour, minute, second, frac) {\n      return this.time(+hour, +minute, +second, +frac.substr(0, 3));\n    }\n  },\n\n  dateTextual: {\n    regex: RegExp('^' + reMonthText + '[ .\\\\t-]*' + reDay + '[,.stndrh\\\\t ]+' + reYear, 'i'),\n    name: 'datetextual',\n    callback: function callback(match, month, day, year) {\n      return this.ymd(processYear(year), lookupMonth(month), +day);\n    }\n  },\n\n  pointedDate4: {\n    regex: RegExp('^' + reDay + '[.\\\\t-]' + reMonth + '[.-]' + reYear4),\n    name: 'pointeddate4',\n    callback: function callback(match, day, month, year) {\n      return this.ymd(+year, month - 1, +day);\n    }\n  },\n\n  pointedDate2: {\n    regex: RegExp('^' + reDay + '[.\\\\t]' + reMonth + '\\\\.' + reYear2),\n    name: 'pointeddate2',\n    callback: function callback(match, day, month, year) {\n      return this.ymd(processYear(year), month - 1, +day);\n    }\n  },\n\n  timeLong24: {\n    regex: RegExp('^t?' + reHour24 + '[:.]' + reMinute + '[:.]' + reSecond),\n    name: 'timelong24',\n    callback: function callback(match, hour, minute, second) {\n      return this.time(+hour, +minute, +second, 0);\n    }\n  },\n\n  dateNoColon: {\n    regex: RegExp('^' + reYear4 + reMonthlz + reDaylz),\n    name: 'datenocolon',\n    callback: function callback(match, year, month, day) {\n      return this.ymd(+year, month - 1, +day);\n    }\n  },\n\n  pgydotd: {\n    regex: RegExp('^' + reYear4 + '\\\\.?' + reDayOfYear),\n    name: 'pgydotd',\n    callback: function callback(match, year, day) {\n      return this.ymd(+year, 0, +day);\n    }\n  },\n\n  timeShort24: {\n    regex: RegExp('^t?' + reHour24 + '[:.]' + reMinute, 'i'),\n    name: 'timeshort24',\n    callback: function callback(match, hour, minute) {\n      return this.time(+hour, +minute, 0, 0);\n    }\n  },\n\n  iso8601noColon: {\n    regex: RegExp('^t?' + reHour24lz + reMinutelz + reSecondlz, 'i'),\n    name: 'iso8601nocolon',\n    callback: function callback(match, hour, minute, second) {\n      return this.time(+hour, +minute, +second, 0);\n    }\n  },\n\n  iso8601dateSlash: {\n    // eventhough the trailing slash is optional in PHP\n    // here it's mandatory and inputs without the slash\n    // are handled by dateslash\n    regex: RegExp('^' + reYear4 + '/' + reMonthlz + '/' + reDaylz + '/'),\n    name: 'iso8601dateslash',\n    callback: function callback(match, year, month, day) {\n      return this.ymd(+year, month - 1, +day);\n    }\n  },\n\n  dateSlash: {\n    regex: RegExp('^' + reYear4 + '/' + reMonth + '/' + reDay),\n    name: 'dateslash',\n    callback: function callback(match, year, month, day) {\n      return this.ymd(+year, month - 1, +day);\n    }\n  },\n\n  american: {\n    regex: RegExp('^' + reMonth + '/' + reDay + '/' + reYear),\n    name: 'american',\n    callback: function callback(match, month, day, year) {\n      return this.ymd(processYear(year), month - 1, +day);\n    }\n  },\n\n  americanShort: {\n    regex: RegExp('^' + reMonth + '/' + reDay),\n    name: 'americanshort',\n    callback: function callback(match, month, day) {\n      return this.ymd(this.y, month - 1, +day);\n    }\n  },\n\n  gnuDateShortOrIso8601date2: {\n    // iso8601date2 is complete subset of gnudateshort\n    regex: RegExp('^' + reYear + '-' + reMonth + '-' + reDay),\n    name: 'gnudateshort | iso8601date2',\n    callback: function callback(match, year, month, day) {\n      return this.ymd(processYear(year), month - 1, +day);\n    }\n  },\n\n  iso8601date4: {\n    regex: RegExp('^' + reYear4withSign + '-' + reMonthlz + '-' + reDaylz),\n    name: 'iso8601date4',\n    callback: function callback(match, year, month, day) {\n      return this.ymd(+year, month - 1, +day);\n    }\n  },\n\n  gnuNoColon: {\n    regex: RegExp('^t?' + reHour24lz + reMinutelz, 'i'),\n    name: 'gnunocolon',\n    callback: function callback(match, hour, minute) {\n      // this rule is a special case\n      // if time was already set once by any preceding rule, it sets the captured value as year\n      switch (this.times) {\n        case 0:\n          return this.time(+hour, +minute, 0, this.f);\n        case 1:\n          this.y = hour * 100 + +minute;\n          this.times++;\n\n          return true;\n        default:\n          return false;\n      }\n    }\n  },\n\n  gnuDateShorter: {\n    regex: RegExp('^' + reYear4 + '-' + reMonth),\n    name: 'gnudateshorter',\n    callback: function callback(match, year, month) {\n      return this.ymd(+year, month - 1, 1);\n    }\n  },\n\n  pgTextReverse: {\n    // note: allowed years are from 32-9999\n    // years below 32 should be treated as days in datefull\n    regex: RegExp('^' + '(\\\\d{3,4}|[4-9]\\\\d|3[2-9])-(' + reMonthAbbr + ')-' + reDaylz, 'i'),\n    name: 'pgtextreverse',\n    callback: function callback(match, year, month, day) {\n      return this.ymd(processYear(year), lookupMonth(month), +day);\n    }\n  },\n\n  dateFull: {\n    regex: RegExp('^' + reDay + '[ \\\\t.-]*' + reMonthText + '[ \\\\t.-]*' + reYear, 'i'),\n    name: 'datefull',\n    callback: function callback(match, day, month, year) {\n      return this.ymd(processYear(year), lookupMonth(month), +day);\n    }\n  },\n\n  dateNoDay: {\n    regex: RegExp('^' + reMonthText + '[ .\\\\t-]*' + reYear4, 'i'),\n    name: 'datenoday',\n    callback: function callback(match, month, year) {\n      return this.ymd(+year, lookupMonth(month), 1);\n    }\n  },\n\n  dateNoDayRev: {\n    regex: RegExp('^' + reYear4 + '[ .\\\\t-]*' + reMonthText, 'i'),\n    name: 'datenodayrev',\n    callback: function callback(match, year, month) {\n      return this.ymd(+year, lookupMonth(month), 1);\n    }\n  },\n\n  pgTextShort: {\n    regex: RegExp('^(' + reMonthAbbr + ')-' + reDaylz + '-' + reYear, 'i'),\n    name: 'pgtextshort',\n    callback: function callback(match, month, day, year) {\n      return this.ymd(processYear(year), lookupMonth(month), +day);\n    }\n  },\n\n  dateNoYear: {\n    regex: RegExp('^' + reDateNoYear, 'i'),\n    name: 'datenoyear',\n    callback: function callback(match, month, day) {\n      return this.ymd(this.y, lookupMonth(month), +day);\n    }\n  },\n\n  dateNoYearRev: {\n    regex: RegExp('^' + reDay + '[ .\\\\t-]*' + reMonthText, 'i'),\n    name: 'datenoyearrev',\n    callback: function callback(match, day, month) {\n      return this.ymd(this.y, lookupMonth(month), +day);\n    }\n  },\n\n  isoWeekDay: {\n    regex: RegExp('^' + reYear4 + '-?W' + reWeekOfYear + '(?:-?([0-7]))?'),\n    name: 'isoweekday | isoweek',\n    callback: function callback(match, year, week, day) {\n      day = day ? +day : 1;\n\n      if (!this.ymd(+year, 0, 1)) {\n        return false;\n      }\n\n      // get day of week for Jan 1st\n      var dayOfWeek = new Date(this.y, this.m, this.d).getDay();\n\n      // and use the day to figure out the offset for day 1 of week 1\n      dayOfWeek = 0 - (dayOfWeek > 4 ? dayOfWeek - 7 : dayOfWeek);\n\n      this.rd += dayOfWeek + (week - 1) * 7 + day;\n    }\n  },\n\n  relativeText: {\n    regex: RegExp('^(' + reReltextnumber + '|' + reReltexttext + ')' + reSpace + '(' + reReltextunit + ')', 'i'),\n    name: 'relativetext',\n    callback: function callback(match, relValue, relUnit) {\n      // todo: implement handling of 'this time-unit'\n      // eslint-disable-next-line no-unused-vars\n      var _lookupRelative = lookupRelative(relValue),\n          amount = _lookupRelative.amount,\n          behavior = _lookupRelative.behavior;\n\n      switch (relUnit.toLowerCase()) {\n        case 'sec':\n        case 'secs':\n        case 'second':\n        case 'seconds':\n          this.rs += amount;\n          break;\n        case 'min':\n        case 'mins':\n        case 'minute':\n        case 'minutes':\n          this.ri += amount;\n          break;\n        case 'hour':\n        case 'hours':\n          this.rh += amount;\n          break;\n        case 'day':\n        case 'days':\n          this.rd += amount;\n          break;\n        case 'fortnight':\n        case 'fortnights':\n        case 'forthnight':\n        case 'forthnights':\n          this.rd += amount * 14;\n          break;\n        case 'week':\n        case 'weeks':\n          this.rd += amount * 7;\n          break;\n        case 'month':\n        case 'months':\n          this.rm += amount;\n          break;\n        case 'year':\n        case 'years':\n          this.ry += amount;\n          break;\n        case 'mon':case 'monday':\n        case 'tue':case 'tuesday':\n        case 'wed':case 'wednesday':\n        case 'thu':case 'thursday':\n        case 'fri':case 'friday':\n        case 'sat':case 'saturday':\n        case 'sun':case 'sunday':\n          this.resetTime();\n          this.weekday = lookupWeekday(relUnit, 7);\n          this.weekdayBehavior = 1;\n          this.rd += (amount > 0 ? amount - 1 : amount) * 7;\n          break;\n        case 'weekday':\n        case 'weekdays':\n          // todo\n          break;\n      }\n    }\n  },\n\n  relative: {\n    regex: RegExp('^([+-]*)[ \\\\t]*(\\\\d+)' + reSpaceOpt + '(' + reReltextunit + '|week)', 'i'),\n    name: 'relative',\n    callback: function callback(match, signs, relValue, relUnit) {\n      var minuses = signs.replace(/[^-]/g, '').length;\n\n      var amount = +relValue * Math.pow(-1, minuses);\n\n      switch (relUnit.toLowerCase()) {\n        case 'sec':\n        case 'secs':\n        case 'second':\n        case 'seconds':\n          this.rs += amount;\n          break;\n        case 'min':\n        case 'mins':\n        case 'minute':\n        case 'minutes':\n          this.ri += amount;\n          break;\n        case 'hour':\n        case 'hours':\n          this.rh += amount;\n          break;\n        case 'day':\n        case 'days':\n          this.rd += amount;\n          break;\n        case 'fortnight':\n        case 'fortnights':\n        case 'forthnight':\n        case 'forthnights':\n          this.rd += amount * 14;\n          break;\n        case 'week':\n        case 'weeks':\n          this.rd += amount * 7;\n          break;\n        case 'month':\n        case 'months':\n          this.rm += amount;\n          break;\n        case 'year':\n        case 'years':\n          this.ry += amount;\n          break;\n        case 'mon':case 'monday':\n        case 'tue':case 'tuesday':\n        case 'wed':case 'wednesday':\n        case 'thu':case 'thursday':\n        case 'fri':case 'friday':\n        case 'sat':case 'saturday':\n        case 'sun':case 'sunday':\n          this.resetTime();\n          this.weekday = lookupWeekday(relUnit, 7);\n          this.weekdayBehavior = 1;\n          this.rd += (amount > 0 ? amount - 1 : amount) * 7;\n          break;\n        case 'weekday':\n        case 'weekdays':\n          // todo\n          break;\n      }\n    }\n  },\n\n  dayText: {\n    regex: RegExp('^(' + reDaytext + ')', 'i'),\n    name: 'daytext',\n    callback: function callback(match, dayText) {\n      this.resetTime();\n      this.weekday = lookupWeekday(dayText, 0);\n\n      if (this.weekdayBehavior !== 2) {\n        this.weekdayBehavior = 1;\n      }\n    }\n  },\n\n  relativeTextWeek: {\n    regex: RegExp('^(' + reReltexttext + ')' + reSpace + 'week', 'i'),\n    name: 'relativetextweek',\n    callback: function callback(match, relText) {\n      this.weekdayBehavior = 2;\n\n      switch (relText.toLowerCase()) {\n        case 'this':\n          this.rd += 0;\n          break;\n        case 'next':\n          this.rd += 7;\n          break;\n        case 'last':\n        case 'previous':\n          this.rd -= 7;\n          break;\n      }\n\n      if (isNaN(this.weekday)) {\n        this.weekday = 1;\n      }\n    }\n  },\n\n  monthFullOrMonthAbbr: {\n    regex: RegExp('^(' + reMonthFull + '|' + reMonthAbbr + ')', 'i'),\n    name: 'monthfull | monthabbr',\n    callback: function callback(match, month) {\n      return this.ymd(this.y, lookupMonth(month), this.d);\n    }\n  },\n\n  tzCorrection: {\n    regex: RegExp('^' + reTzCorrection, 'i'),\n    name: 'tzcorrection',\n    callback: function callback(tzCorrection) {\n      return this.zone(processTzCorrection(tzCorrection));\n    }\n  },\n\n  ago: {\n    regex: /^ago/i,\n    name: 'ago',\n    callback: function callback() {\n      this.ry = -this.ry;\n      this.rm = -this.rm;\n      this.rd = -this.rd;\n      this.rh = -this.rh;\n      this.ri = -this.ri;\n      this.rs = -this.rs;\n      this.rf = -this.rf;\n    }\n  },\n\n  year4: {\n    regex: RegExp('^' + reYear4),\n    name: 'year4',\n    callback: function callback(match, year) {\n      this.y = +year;\n      return true;\n    }\n  },\n\n  whitespace: {\n    regex: /^[ .,\\t]+/,\n    name: 'whitespace'\n    // do nothing\n  },\n\n  dateShortWithTimeLong: {\n    regex: RegExp('^' + reDateNoYear + 't?' + reHour24 + '[:.]' + reMinute + '[:.]' + reSecond, 'i'),\n    name: 'dateshortwithtimelong',\n    callback: function callback(match, month, day, hour, minute, second) {\n      return this.ymd(this.y, lookupMonth(month), +day) && this.time(+hour, +minute, +second, 0);\n    }\n  },\n\n  dateShortWithTimeLong12: {\n    regex: RegExp('^' + reDateNoYear + reHour12 + '[:.]' + reMinute + '[:.]' + reSecondlz + reSpaceOpt + reMeridian, 'i'),\n    name: 'dateshortwithtimelong12',\n    callback: function callback(match, month, day, hour, minute, second, meridian) {\n      return this.ymd(this.y, lookupMonth(month), +day) && this.time(processMeridian(+hour, meridian), +minute, +second, 0);\n    }\n  },\n\n  dateShortWithTimeShort: {\n    regex: RegExp('^' + reDateNoYear + 't?' + reHour24 + '[:.]' + reMinute, 'i'),\n    name: 'dateshortwithtimeshort',\n    callback: function callback(match, month, day, hour, minute) {\n      return this.ymd(this.y, lookupMonth(month), +day) && this.time(+hour, +minute, 0, 0);\n    }\n  },\n\n  dateShortWithTimeShort12: {\n    regex: RegExp('^' + reDateNoYear + reHour12 + '[:.]' + reMinutelz + reSpaceOpt + reMeridian, 'i'),\n    name: 'dateshortwithtimeshort12',\n    callback: function callback(match, month, day, hour, minute, meridian) {\n      return this.ymd(this.y, lookupMonth(month), +day) && this.time(processMeridian(+hour, meridian), +minute, 0, 0);\n    }\n  }\n};\n\nvar resultProto = {\n  // date\n  y: NaN,\n  m: NaN,\n  d: NaN,\n  // time\n  h: NaN,\n  i: NaN,\n  s: NaN,\n  f: NaN,\n\n  // relative shifts\n  ry: 0,\n  rm: 0,\n  rd: 0,\n  rh: 0,\n  ri: 0,\n  rs: 0,\n  rf: 0,\n\n  // weekday related shifts\n  weekday: NaN,\n  weekdayBehavior: 0,\n\n  // first or last day of month\n  // 0 none, 1 first, -1 last\n  firstOrLastDayOfMonth: 0,\n\n  // timezone correction in minutes\n  z: NaN,\n\n  // counters\n  dates: 0,\n  times: 0,\n  zones: 0,\n\n  // helper functions\n  ymd: function ymd(y, m, d) {\n    if (this.dates > 0) {\n      return false;\n    }\n\n    this.dates++;\n    this.y = y;\n    this.m = m;\n    this.d = d;\n    return true;\n  },\n  time: function time(h, i, s, f) {\n    if (this.times > 0) {\n      return false;\n    }\n\n    this.times++;\n    this.h = h;\n    this.i = i;\n    this.s = s;\n    this.f = f;\n\n    return true;\n  },\n  resetTime: function resetTime() {\n    this.h = 0;\n    this.i = 0;\n    this.s = 0;\n    this.f = 0;\n    this.times = 0;\n\n    return true;\n  },\n  zone: function zone(minutes) {\n    if (this.zones <= 1) {\n      this.zones++;\n      this.z = minutes;\n      return true;\n    }\n\n    return false;\n  },\n  toDate: function toDate(relativeTo) {\n    if (this.dates && !this.times) {\n      this.h = this.i = this.s = this.f = 0;\n    }\n\n    // fill holes\n    if (isNaN(this.y)) {\n      this.y = relativeTo.getFullYear();\n    }\n\n    if (isNaN(this.m)) {\n      this.m = relativeTo.getMonth();\n    }\n\n    if (isNaN(this.d)) {\n      this.d = relativeTo.getDate();\n    }\n\n    if (isNaN(this.h)) {\n      this.h = relativeTo.getHours();\n    }\n\n    if (isNaN(this.i)) {\n      this.i = relativeTo.getMinutes();\n    }\n\n    if (isNaN(this.s)) {\n      this.s = relativeTo.getSeconds();\n    }\n\n    if (isNaN(this.f)) {\n      this.f = relativeTo.getMilliseconds();\n    }\n\n    // adjust special early\n    switch (this.firstOrLastDayOfMonth) {\n      case 1:\n        this.d = 1;\n        break;\n      case -1:\n        this.d = 0;\n        this.m += 1;\n        break;\n    }\n\n    if (!isNaN(this.weekday)) {\n      var date = new Date(relativeTo.getTime());\n      date.setFullYear(this.y, this.m, this.d);\n      date.setHours(this.h, this.i, this.s, this.f);\n\n      var dow = date.getDay();\n\n      if (this.weekdayBehavior === 2) {\n        // To make \"this week\" work, where the current day of week is a \"sunday\"\n        if (dow === 0 && this.weekday !== 0) {\n          this.weekday = -6;\n        }\n\n        // To make \"sunday this week\" work, where the current day of week is not a \"sunday\"\n        if (this.weekday === 0 && dow !== 0) {\n          this.weekday = 7;\n        }\n\n        this.d -= dow;\n        this.d += this.weekday;\n      } else {\n        var diff = this.weekday - dow;\n\n        // some PHP magic\n        if (this.rd < 0 && diff < 0 || this.rd >= 0 && diff <= -this.weekdayBehavior) {\n          diff += 7;\n        }\n\n        if (this.weekday >= 0) {\n          this.d += diff;\n        } else {\n          this.d -= 7 - (Math.abs(this.weekday) - dow);\n        }\n\n        this.weekday = NaN;\n      }\n    }\n\n    // adjust relative\n    this.y += this.ry;\n    this.m += this.rm;\n    this.d += this.rd;\n\n    this.h += this.rh;\n    this.i += this.ri;\n    this.s += this.rs;\n    this.f += this.rf;\n\n    this.ry = this.rm = this.rd = 0;\n    this.rh = this.ri = this.rs = this.rf = 0;\n\n    var result = new Date(relativeTo.getTime());\n    // since Date constructor treats years <= 99 as 1900+\n    // it can't be used, thus this weird way\n    result.setFullYear(this.y, this.m, this.d);\n    result.setHours(this.h, this.i, this.s, this.f);\n\n    // note: this is done twice in PHP\n    // early when processing special relatives\n    // and late\n    // todo: check if the logic can be reduced\n    // to just one time action\n    switch (this.firstOrLastDayOfMonth) {\n      case 1:\n        result.setDate(1);\n        break;\n      case -1:\n        result.setMonth(result.getMonth() + 1, 0);\n        break;\n    }\n\n    // adjust timezone\n    if (!isNaN(this.z) && result.getTimezoneOffset() !== this.z) {\n      result.setUTCFullYear(result.getFullYear(), result.getMonth(), result.getDate());\n\n      result.setUTCHours(result.getHours(), result.getMinutes() + this.z, result.getSeconds(), result.getMilliseconds());\n    }\n\n    return result;\n  }\n};\n\nmodule.exports = function strtotime(str, now) {\n  //       discuss at: https://locutus.io/php/strtotime/\n  //      original by: Caio Ariede (https://caioariede.com)\n  //      improved by: Kevin van Zonneveld (https://kvz.io)\n  //      improved by: Caio Ariede (https://caioariede.com)\n  //      improved by: A. Matías Quezada (https://amatiasq.com)\n  //      improved by: preuter\n  //      improved by: Brett Zamir (https://brett-zamir.me)\n  //      improved by: Mirko Faber\n  //         input by: David\n  //      bugfixed by: Wagner B. Soares\n  //      bugfixed by: Artur Tchernychev\n  //      bugfixed by: Stephan Bösch-Plepelits (https://github.com/plepe)\n  // reimplemented by: Rafał Kukawski\n  //           note 1: Examples all have a fixed timestamp to prevent\n  //           note 1: tests to fail because of variable time(zones)\n  //        example 1: strtotime('+1 day', 1129633200)\n  //        returns 1: 1129719600\n  //        example 2: strtotime('+1 week 2 days 4 hours 2 seconds', 1129633200)\n  //        returns 2: 1130425202\n  //        example 3: strtotime('last month', 1129633200)\n  //        returns 3: 1127041200\n  //        example 4: strtotime('2009-05-04 08:30:00+00')\n  //        returns 4: 1241425800\n  //        example 5: strtotime('2009-05-04 08:30:00+02:00')\n  //        returns 5: 1241418600\n\n  if (now == null) {\n    now = Math.floor(Date.now() / 1000);\n  }\n\n  // the rule order is important\n  // if multiple rules match, the longest match wins\n  // if multiple rules match the same string, the first match wins\n  var rules = [formats.yesterday, formats.now, formats.noon, formats.midnightOrToday, formats.tomorrow, formats.timestamp, formats.firstOrLastDay, formats.backOrFrontOf,\n  // formats.weekdayOf, // not yet implemented\n  formats.timeTiny12, formats.timeShort12, formats.timeLong12, formats.mssqltime, formats.timeShort24, formats.timeLong24, formats.iso8601long, formats.gnuNoColon, formats.iso8601noColon, formats.americanShort, formats.american, formats.iso8601date4, formats.iso8601dateSlash, formats.dateSlash, formats.gnuDateShortOrIso8601date2, formats.gnuDateShorter, formats.dateFull, formats.pointedDate4, formats.pointedDate2, formats.dateNoDay, formats.dateNoDayRev, formats.dateTextual, formats.dateNoYear, formats.dateNoYearRev, formats.dateNoColon, formats.xmlRpc, formats.xmlRpcNoColon, formats.soap, formats.wddx, formats.exif, formats.pgydotd, formats.isoWeekDay, formats.pgTextShort, formats.pgTextReverse, formats.clf, formats.year4, formats.ago, formats.dayText, formats.relativeTextWeek, formats.relativeText, formats.monthFullOrMonthAbbr, formats.tzCorrection, formats.dateShortWithTimeShort12, formats.dateShortWithTimeLong12, formats.dateShortWithTimeShort, formats.dateShortWithTimeLong, formats.relative, formats.whitespace];\n\n  var result = Object.create(resultProto);\n\n  while (str.length) {\n    var longestMatch = null;\n    var finalRule = null;\n\n    for (var i = 0, l = rules.length; i < l; i++) {\n      var format = rules[i];\n\n      var match = str.match(format.regex);\n\n      if (match) {\n        if (!longestMatch || match[0].length > longestMatch[0].length) {\n          longestMatch = match;\n          finalRule = format;\n        }\n      }\n    }\n\n    if (!finalRule || finalRule.callback && finalRule.callback.apply(result, longestMatch) === false) {\n      return false;\n    }\n\n    str = str.substr(longestMatch[0].length);\n    finalRule = null;\n    longestMatch = null;\n  }\n\n  return Math.floor(result.toDate(new Date(now * 1000)) / 1000);\n};\n//# sourceMappingURL=strtotime.js.map","'use strict';\n\nmodule.exports = function date(format, timestamp) {\n  //  discuss at: https://locutus.io/php/date/\n  // original by: Carlos R. L. Rodrigues (https://www.jsfromhell.com)\n  // original by: gettimeofday\n  //    parts by: Peter-Paul Koch (https://www.quirksmode.org/js/beat.html)\n  // improved by: Kevin van Zonneveld (https://kvz.io)\n  // improved by: MeEtc (https://yass.meetcweb.com)\n  // improved by: Brad Touesnard\n  // improved by: Tim Wiel\n  // improved by: Bryan Elliott\n  // improved by: David Randall\n  // improved by: Theriault (https://github.com/Theriault)\n  // improved by: Theriault (https://github.com/Theriault)\n  // improved by: Brett Zamir (https://brett-zamir.me)\n  // improved by: Theriault (https://github.com/Theriault)\n  // improved by: Thomas Beaucourt (https://www.webapp.fr)\n  // improved by: JT\n  // improved by: Theriault (https://github.com/Theriault)\n  // improved by: Rafał Kukawski (https://blog.kukawski.pl)\n  // improved by: Theriault (https://github.com/Theriault)\n  //    input by: Brett Zamir (https://brett-zamir.me)\n  //    input by: majak\n  //    input by: Alex\n  //    input by: Martin\n  //    input by: Alex Wilson\n  //    input by: Haravikk\n  // bugfixed by: Kevin van Zonneveld (https://kvz.io)\n  // bugfixed by: majak\n  // bugfixed by: Kevin van Zonneveld (https://kvz.io)\n  // bugfixed by: Brett Zamir (https://brett-zamir.me)\n  // bugfixed by: omid (https://locutus.io/php/380:380#comment_137122)\n  // bugfixed by: Chris (https://www.devotis.nl/)\n  //      note 1: Uses global: locutus to store the default timezone\n  //      note 1: Although the function potentially allows timezone info\n  //      note 1: (see notes), it currently does not set\n  //      note 1: per a timezone specified by date_default_timezone_set(). Implementers might use\n  //      note 1: $locutus.currentTimezoneOffset and\n  //      note 1: $locutus.currentTimezoneDST set by that function\n  //      note 1: in order to adjust the dates in this function\n  //      note 1: (or our other date functions!) accordingly\n  //   example 1: date('H:m:s \\\\m \\\\i\\\\s \\\\m\\\\o\\\\n\\\\t\\\\h', 1062402400)\n  //   returns 1: '07:09:40 m is month'\n  //   example 2: date('F j, Y, g:i a', 1062462400)\n  //   returns 2: 'September 2, 2003, 12:26 am'\n  //   example 3: date('Y W o', 1062462400)\n  //   returns 3: '2003 36 2003'\n  //   example 4: var $x = date('Y m d', (new Date()).getTime() / 1000)\n  //   example 4: $x = $x + ''\n  //   example 4: var $result = $x.length // 2009 01 09\n  //   returns 4: 10\n  //   example 5: date('W', 1104534000)\n  //   returns 5: '52'\n  //   example 6: date('B t', 1104534000)\n  //   returns 6: '999 31'\n  //   example 7: date('W U', 1293750000.82); // 2010-12-31\n  //   returns 7: '52 1293750000'\n  //   example 8: date('W', 1293836400); // 2011-01-01\n  //   returns 8: '52'\n  //   example 9: date('W Y-m-d', 1293974054); // 2011-01-02\n  //   returns 9: '52 2011-01-02'\n  //        test: skip-1 skip-2 skip-5\n\n  var jsdate, f;\n  // Keep this here (works, but for code commented-out below for file size reasons)\n  // var tal= [];\n  var txtWords = ['Sun', 'Mon', 'Tues', 'Wednes', 'Thurs', 'Fri', 'Satur', 'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];\n  // trailing backslash -> (dropped)\n  // a backslash followed by any character (including backslash) -> the character\n  // empty string -> empty string\n  var formatChr = /\\\\?(.?)/gi;\n  var formatChrCb = function formatChrCb(t, s) {\n    return f[t] ? f[t]() : s;\n  };\n  var _pad = function _pad(n, c) {\n    n = String(n);\n    while (n.length < c) {\n      n = '0' + n;\n    }\n    return n;\n  };\n  f = {\n    // Day\n    d: function d() {\n      // Day of month w/leading 0; 01..31\n      return _pad(f.j(), 2);\n    },\n    D: function D() {\n      // Shorthand day name; Mon...Sun\n      return f.l().slice(0, 3);\n    },\n    j: function j() {\n      // Day of month; 1..31\n      return jsdate.getDate();\n    },\n    l: function l() {\n      // Full day name; Monday...Sunday\n      return txtWords[f.w()] + 'day';\n    },\n    N: function N() {\n      // ISO-8601 day of week; 1[Mon]..7[Sun]\n      return f.w() || 7;\n    },\n    S: function S() {\n      // Ordinal suffix for day of month; st, nd, rd, th\n      var j = f.j();\n      var i = j % 10;\n      if (i <= 3 && parseInt(j % 100 / 10, 10) === 1) {\n        i = 0;\n      }\n      return ['st', 'nd', 'rd'][i - 1] || 'th';\n    },\n    w: function w() {\n      // Day of week; 0[Sun]..6[Sat]\n      return jsdate.getDay();\n    },\n    z: function z() {\n      // Day of year; 0..365\n      var a = new Date(f.Y(), f.n() - 1, f.j());\n      var b = new Date(f.Y(), 0, 1);\n      return Math.round((a - b) / 864e5);\n    },\n\n    // Week\n    W: function W() {\n      // ISO-8601 week number\n      var a = new Date(f.Y(), f.n() - 1, f.j() - f.N() + 3);\n      var b = new Date(a.getFullYear(), 0, 4);\n      return _pad(1 + Math.round((a - b) / 864e5 / 7), 2);\n    },\n\n    // Month\n    F: function F() {\n      // Full month name; January...December\n      return txtWords[6 + f.n()];\n    },\n    m: function m() {\n      // Month w/leading 0; 01...12\n      return _pad(f.n(), 2);\n    },\n    M: function M() {\n      // Shorthand month name; Jan...Dec\n      return f.F().slice(0, 3);\n    },\n    n: function n() {\n      // Month; 1...12\n      return jsdate.getMonth() + 1;\n    },\n    t: function t() {\n      // Days in month; 28...31\n      return new Date(f.Y(), f.n(), 0).getDate();\n    },\n\n    // Year\n    L: function L() {\n      // Is leap year?; 0 or 1\n      var j = f.Y();\n      return j % 4 === 0 & j % 100 !== 0 | j % 400 === 0;\n    },\n    o: function o() {\n      // ISO-8601 year\n      var n = f.n();\n      var W = f.W();\n      var Y = f.Y();\n      return Y + (n === 12 && W < 9 ? 1 : n === 1 && W > 9 ? -1 : 0);\n    },\n    Y: function Y() {\n      // Full year; e.g. 1980...2010\n      return jsdate.getFullYear();\n    },\n    y: function y() {\n      // Last two digits of year; 00...99\n      return f.Y().toString().slice(-2);\n    },\n\n    // Time\n    a: function a() {\n      // am or pm\n      return jsdate.getHours() > 11 ? 'pm' : 'am';\n    },\n    A: function A() {\n      // AM or PM\n      return f.a().toUpperCase();\n    },\n    B: function B() {\n      // Swatch Internet time; 000..999\n      var H = jsdate.getUTCHours() * 36e2;\n      // Hours\n      var i = jsdate.getUTCMinutes() * 60;\n      // Minutes\n      // Seconds\n      var s = jsdate.getUTCSeconds();\n      return _pad(Math.floor((H + i + s + 36e2) / 86.4) % 1e3, 3);\n    },\n    g: function g() {\n      // 12-Hours; 1..12\n      return f.G() % 12 || 12;\n    },\n    G: function G() {\n      // 24-Hours; 0..23\n      return jsdate.getHours();\n    },\n    h: function h() {\n      // 12-Hours w/leading 0; 01..12\n      return _pad(f.g(), 2);\n    },\n    H: function H() {\n      // 24-Hours w/leading 0; 00..23\n      return _pad(f.G(), 2);\n    },\n    i: function i() {\n      // Minutes w/leading 0; 00..59\n      return _pad(jsdate.getMinutes(), 2);\n    },\n    s: function s() {\n      // Seconds w/leading 0; 00..59\n      return _pad(jsdate.getSeconds(), 2);\n    },\n    u: function u() {\n      // Microseconds; 000000-999000\n      return _pad(jsdate.getMilliseconds() * 1000, 6);\n    },\n\n    // Timezone\n    e: function e() {\n      // Timezone identifier; e.g. Atlantic/Azores, ...\n      // The following works, but requires inclusion of the very large\n      // timezone_abbreviations_list() function.\n      /*              return that.date_default_timezone_get();\n       */\n      var msg = 'Not supported (see source code of date() for timezone on how to add support)';\n      throw new Error(msg);\n    },\n    I: function I() {\n      // DST observed?; 0 or 1\n      // Compares Jan 1 minus Jan 1 UTC to Jul 1 minus Jul 1 UTC.\n      // If they are not equal, then DST is observed.\n      var a = new Date(f.Y(), 0);\n      // Jan 1\n      var c = Date.UTC(f.Y(), 0);\n      // Jan 1 UTC\n      var b = new Date(f.Y(), 6);\n      // Jul 1\n      // Jul 1 UTC\n      var d = Date.UTC(f.Y(), 6);\n      return a - c !== b - d ? 1 : 0;\n    },\n    O: function O() {\n      // Difference to GMT in hour format; e.g. +0200\n      var tzo = jsdate.getTimezoneOffset();\n      var a = Math.abs(tzo);\n      return (tzo > 0 ? '-' : '+') + _pad(Math.floor(a / 60) * 100 + a % 60, 4);\n    },\n    P: function P() {\n      // Difference to GMT w/colon; e.g. +02:00\n      var O = f.O();\n      return O.substr(0, 3) + ':' + O.substr(3, 2);\n    },\n    T: function T() {\n      // The following works, but requires inclusion of the very\n      // large timezone_abbreviations_list() function.\n      /*              var abbr, i, os, _default;\n      if (!tal.length) {\n        tal = that.timezone_abbreviations_list();\n      }\n      if ($locutus && $locutus.default_timezone) {\n        _default = $locutus.default_timezone;\n        for (abbr in tal) {\n          for (i = 0; i < tal[abbr].length; i++) {\n            if (tal[abbr][i].timezone_id === _default) {\n              return abbr.toUpperCase();\n            }\n          }\n        }\n      }\n      for (abbr in tal) {\n        for (i = 0; i < tal[abbr].length; i++) {\n          os = -jsdate.getTimezoneOffset() * 60;\n          if (tal[abbr][i].offset === os) {\n            return abbr.toUpperCase();\n          }\n        }\n      }\n      */\n      return 'UTC';\n    },\n    Z: function Z() {\n      // Timezone offset in seconds (-43200...50400)\n      return -jsdate.getTimezoneOffset() * 60;\n    },\n\n    // Full Date/Time\n    c: function c() {\n      // ISO-8601 date.\n      return 'Y-m-d\\\\TH:i:sP'.replace(formatChr, formatChrCb);\n    },\n    r: function r() {\n      // RFC 2822\n      return 'D, d M Y H:i:s O'.replace(formatChr, formatChrCb);\n    },\n    U: function U() {\n      // Seconds since UNIX epoch\n      return jsdate / 1000 | 0;\n    }\n  };\n\n  var _date = function _date(format, timestamp) {\n    jsdate = timestamp === undefined ? new Date() // Not provided\n    : timestamp instanceof Date ? new Date(timestamp) // JS Date()\n    : new Date(timestamp * 1000) // UNIX timestamp (auto-convert to int)\n    ;\n    return format.replace(formatChr, formatChrCb);\n  };\n\n  return _date(format, timestamp);\n};\n//# sourceMappingURL=date.js.map","'use strict';\n\nmodule.exports = function boolval(mixedVar) {\n  // original by: Will Rowe\n  //   example 1: boolval(true)\n  //   returns 1: true\n  //   example 2: boolval(false)\n  //   returns 2: false\n  //   example 3: boolval(0)\n  //   returns 3: false\n  //   example 4: boolval(0.0)\n  //   returns 4: false\n  //   example 5: boolval('')\n  //   returns 5: false\n  //   example 6: boolval('0')\n  //   returns 6: false\n  //   example 7: boolval([])\n  //   returns 7: false\n  //   example 8: boolval('')\n  //   returns 8: false\n  //   example 9: boolval(null)\n  //   returns 9: false\n  //   example 10: boolval(undefined)\n  //   returns 10: false\n  //   example 11: boolval('true')\n  //   returns 11: true\n\n  if (mixedVar === false) {\n    return false;\n  }\n\n  if (mixedVar === 0 || mixedVar === 0.0) {\n    return false;\n  }\n\n  if (mixedVar === '' || mixedVar === '0') {\n    return false;\n  }\n\n  if (Array.isArray(mixedVar) && mixedVar.length === 0) {\n    return false;\n  }\n\n  if (mixedVar === null || mixedVar === undefined) {\n    return false;\n  }\n\n  return true;\n};\n//# sourceMappingURL=boolval.js.map","module.exports = function (Twig) {\n    'use strict';\n\n    Twig.Templates.registerLoader('ajax', function (location, params, callback, errorCallback) {\n        let template;\n        const {precompiled} = params;\n        const parser = this.parsers[params.parser] || this.parser.twig;\n\n        if (typeof XMLHttpRequest === 'undefined') {\n            throw new Twig.Error('Unsupported platform: Unable to do ajax requests ' +\n                                 'because there is no \"XMLHTTPRequest\" implementation');\n        }\n\n        const xmlhttp = new XMLHttpRequest();\n        xmlhttp.onreadystatechange = function () {\n            let data = null;\n\n            if (xmlhttp.readyState === 4) {\n                if (xmlhttp.status === 200 || (window.cordova && xmlhttp.status === 0)) {\n                    Twig.log.debug('Got template ', xmlhttp.responseText);\n\n                    if (precompiled === true) {\n                        data = JSON.parse(xmlhttp.responseText);\n                    } else {\n                        data = xmlhttp.responseText;\n                    }\n\n                    params.url = location;\n                    params.data = data;\n\n                    template = parser.call(this, params);\n\n                    if (typeof callback === 'function') {\n                        callback(template);\n                    }\n                } else if (typeof errorCallback === 'function') {\n                    errorCallback(xmlhttp);\n                }\n            }\n        };\n\n        xmlhttp.open('GET', location, Boolean(params.async));\n        xmlhttp.overrideMimeType('text/plain');\n        xmlhttp.send();\n\n        if (params.async) {\n            // TODO: return deferred promise\n            return true;\n        }\n\n        return template;\n    });\n};\n","module.exports = function (Twig) {\n    'use strict';\n\n    let fs;\n    let path;\n\n    try {\n        // Require lib dependencies at runtime\n        fs = require('fs');\n        path = require('path');\n    } catch (error) {\n        // NOTE: this is in a try/catch to avoid errors cross platform\n        console.warn('Missing fs and path modules. ' + error);\n    }\n\n    Twig.Templates.registerLoader('fs', function (location, params, callback, errorCallback) {\n        let template;\n        let data = null;\n        const {precompiled} = params;\n        const parser = this.parsers[params.parser] || this.parser.twig;\n\n        if (!fs || !path) {\n            throw new Twig.Error('Unsupported platform: Unable to load from file ' +\n                                 'because there is no \"fs\" or \"path\" implementation');\n        }\n\n        const loadTemplateFn = function (err, data) {\n            if (err) {\n                if (typeof errorCallback === 'function') {\n                    errorCallback(err);\n                }\n\n                return;\n            }\n\n            if (precompiled === true) {\n                data = JSON.parse(data);\n            }\n\n            params.data = data;\n            params.path = params.path || location;\n\n            // Template is in data\n            template = parser.call(this, params);\n\n            if (typeof callback === 'function') {\n                callback(template);\n            }\n        };\n\n        params.path = params.path || location;\n\n        if (params.async) {\n            fs.stat(params.path, (err, stats) => {\n                if (err || !stats.isFile()) {\n                    if (typeof errorCallback === 'function') {\n                        errorCallback(new Twig.Error('Unable to find template file ' + params.path));\n                    }\n\n                    return;\n                }\n\n                fs.readFile(params.path, 'utf8', loadTemplateFn);\n            });\n            // TODO: return deferred promise\n            return true;\n        }\n\n        try {\n            if (!fs.statSync(params.path).isFile()) {\n                throw new Twig.Error('Unable to find template file ' + params.path);\n            }\n        } catch (error) {\n            throw new Twig.Error('Unable to find template file ' + params.path + '. ' + error);\n        }\n\n        data = fs.readFileSync(params.path, 'utf8');\n        loadTemplateFn(undefined, data);\n        return template;\n    });\n};\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","// ## twig.logic.js\n//\n// This file handles tokenizing, compiling and parsing logic tokens. {% ... %}\nmodule.exports = function (Twig) {\n    'use strict';\n\n    /**\n     * Namespace for logic handling.\n     */\n    Twig.logic = {};\n\n    /**\n     * Logic token types.\n     */\n    Twig.logic.type = {\n        if_: 'Twig.logic.type.if',\n        endif: 'Twig.logic.type.endif',\n        for_: 'Twig.logic.type.for',\n        endfor: 'Twig.logic.type.endfor',\n        else_: 'Twig.logic.type.else',\n        elseif: 'Twig.logic.type.elseif',\n        set: 'Twig.logic.type.set',\n        setcapture: 'Twig.logic.type.setcapture',\n        endset: 'Twig.logic.type.endset',\n        filter: 'Twig.logic.type.filter',\n        endfilter: 'Twig.logic.type.endfilter',\n        apply: 'Twig.logic.type.apply',\n        endapply: 'Twig.logic.type.endapply',\n        do: 'Twig.logic.type.do',\n        shortblock: 'Twig.logic.type.shortblock',\n        block: 'Twig.logic.type.block',\n        endblock: 'Twig.logic.type.endblock',\n        extends_: 'Twig.logic.type.extends',\n        use: 'Twig.logic.type.use',\n        include: 'Twig.logic.type.include',\n        spaceless: 'Twig.logic.type.spaceless',\n        endspaceless: 'Twig.logic.type.endspaceless',\n        macro: 'Twig.logic.type.macro',\n        endmacro: 'Twig.logic.type.endmacro',\n        import_: 'Twig.logic.type.import',\n        from: 'Twig.logic.type.from',\n        embed: 'Twig.logic.type.embed',\n        endembed: 'Twig.logic.type.endembed',\n        with: 'Twig.logic.type.with',\n        endwith: 'Twig.logic.type.endwith',\n        deprecated: 'Twig.logic.type.deprecated'\n    };\n\n    // Regular expressions for handling logic tokens.\n    //\n    // Properties:\n    //\n    //      type:  The type of expression this matches\n    //\n    //      regex: A regular expression that matches the format of the token\n    //\n    //      next:  What logic tokens (if any) pop this token off the logic stack. If empty, the\n    //             logic token is assumed to not require an end tag and isn't push onto the stack.\n    //\n    //      open:  Does this tag open a logic expression or is it standalone. For example,\n    //             {% endif %} cannot exist without an opening {% if ... %} tag, so open = false.\n    //\n    //  Functions:\n    //\n    //      compile: A function that handles compiling the token into an output token ready for\n    //               parsing with the parse function.\n    //\n    //      parse:   A function that parses the compiled token into output (HTML / whatever the\n    //               template represents).\n    Twig.logic.definitions = [\n        {\n            /**\n             * If type logic tokens.\n             *\n             *  Format: {% if expression %}\n             */\n            type: Twig.logic.type.if_,\n            regex: /^if\\s?([\\s\\S]+)$/,\n            next: [\n                Twig.logic.type.else_,\n                Twig.logic.type.elseif,\n                Twig.logic.type.endif\n            ],\n            open: true,\n            compile(token) {\n                const expression = token.match[1];\n                // Compile the expression.\n                token.stack = Twig.expression.compile.call(this, {\n                    type: Twig.expression.type.expression,\n                    value: expression\n                }).stack;\n                delete token.match;\n                return token;\n            },\n            parse(token, context, chain) {\n                const state = this;\n\n                return Twig.expression.parseAsync.call(state, token.stack, context)\n                    .then(result => {\n                        chain = true;\n\n                        if (Twig.lib.boolval(result)) {\n                            chain = false;\n\n                            return state.parseAsync(token.output, context);\n                        }\n\n                        return '';\n                    })\n                    .then(output => {\n                        return {\n                            chain,\n                            output\n                        };\n                    });\n            }\n        },\n        {\n            /**\n             * Else if type logic tokens.\n             *\n             *  Format: {% elseif expression %}\n             */\n            type: Twig.logic.type.elseif,\n            regex: /^elseif\\s?([^\\s].*)$/,\n            next: [\n                Twig.logic.type.else_,\n                Twig.logic.type.elseif,\n                Twig.logic.type.endif\n            ],\n            open: false,\n            compile(token) {\n                const expression = token.match[1];\n                // Compile the expression.\n                token.stack = Twig.expression.compile.call(this, {\n                    type: Twig.expression.type.expression,\n                    value: expression\n                }).stack;\n                delete token.match;\n                return token;\n            },\n            parse(token, context, chain) {\n                const state = this;\n\n                return Twig.expression.parseAsync.call(state, token.stack, context)\n                    .then(result => {\n                        if (chain && Twig.lib.boolval(result)) {\n                            chain = false;\n\n                            return state.parseAsync(token.output, context);\n                        }\n\n                        return '';\n                    })\n                    .then(output => {\n                        return {\n                            chain,\n                            output\n                        };\n                    });\n            }\n        },\n        {\n            /**\n             * Else type logic tokens.\n             *\n             *  Format: {% else %}\n             */\n            type: Twig.logic.type.else_,\n            regex: /^else$/,\n            next: [\n                Twig.logic.type.endif,\n                Twig.logic.type.endfor\n            ],\n            open: false,\n            parse(token, context, chain) {\n                let promise = Twig.Promise.resolve('');\n                const state = this;\n\n                if (chain) {\n                    promise = state.parseAsync(token.output, context);\n                }\n\n                return promise.then(output => {\n                    return {\n                        chain,\n                        output\n                    };\n                });\n            }\n        },\n        {\n            /**\n             * End if type logic tokens.\n             *\n             *  Format: {% endif %}\n             */\n            type: Twig.logic.type.endif,\n            regex: /^endif$/,\n            next: [],\n            open: false\n        },\n        {\n            /**\n             * For type logic tokens.\n             *\n             *  Format: {% for expression %}\n             */\n            type: Twig.logic.type.for_,\n            regex: /^for\\s+([a-zA-Z0-9_,\\s]+)\\s+in\\s+([\\S\\s]+?)(?:\\s+if\\s+([^\\s].*))?$/,\n            next: [\n                Twig.logic.type.else_,\n                Twig.logic.type.endfor\n            ],\n            open: true,\n            compile(token) {\n                const keyValue = token.match[1];\n                const expression = token.match[2];\n                const conditional = token.match[3];\n                let kvSplit = null;\n\n                token.keyVar = null;\n                token.valueVar = null;\n\n                if (keyValue.includes(',')) {\n                    kvSplit = keyValue.split(',');\n                    if (kvSplit.length === 2) {\n                        token.keyVar = kvSplit[0].trim();\n                        token.valueVar = kvSplit[1].trim();\n                    } else {\n                        throw new Twig.Error('Invalid expression in for loop: ' + keyValue);\n                    }\n                } else {\n                    token.valueVar = keyValue.trim();\n                }\n\n                // Valid expressions for a for loop\n                //   for item     in expression\n                //   for key,item in expression\n\n                // Compile the expression.\n                token.expression = Twig.expression.compile.call(this, {\n                    type: Twig.expression.type.expression,\n                    value: expression\n                }).stack;\n\n                // Compile the conditional (if available)\n                if (conditional) {\n                    token.conditional = Twig.expression.compile.call(this, {\n                        type: Twig.expression.type.expression,\n                        value: conditional\n                    }).stack;\n                }\n\n                delete token.match;\n                return token;\n            },\n            parse(token, context, continueChain) {\n                // Parse expression\n                const output = [];\n                let len;\n                let index = 0;\n                let keyset;\n                const state = this;\n                const {conditional} = token;\n                const buildLoop = function (index, len) {\n                    const isConditional = conditional !== undefined;\n                    return {\n                        index: index + 1,\n                        index0: index,\n                        revindex: isConditional ? undefined : len - index,\n                        revindex0: isConditional ? undefined : len - index - 1,\n                        first: (index === 0),\n                        last: isConditional ? undefined : (index === len - 1),\n                        length: isConditional ? undefined : len,\n                        parent: context\n                    };\n                };\n\n                // Run once for each iteration of the loop\n                const loop = function (key, value) {\n                    const innerContext = {...context};\n\n                    innerContext[token.valueVar] = value;\n\n                    if (token.keyVar) {\n                        innerContext[token.keyVar] = key;\n                    }\n\n                    // Loop object\n                    innerContext.loop = buildLoop(index, len);\n\n                    const promise = conditional === undefined ?\n                        Twig.Promise.resolve(true) :\n                        Twig.expression.parseAsync.call(state, conditional, innerContext);\n\n                    return promise.then(condition => {\n                        if (!condition) {\n                            return;\n                        }\n\n                        return state.parseAsync(token.output, innerContext)\n                            .then(tokenOutput => {\n                                output.push(tokenOutput);\n                                index += 1;\n                            });\n                    })\n                        .then(() => {\n                            // Delete loop-related variables from the context\n                            delete innerContext.loop;\n                            delete innerContext[token.valueVar];\n                            delete innerContext[token.keyVar];\n\n                            // Merge in values that exist in context but have changed\n                            // in inner_context.\n                            Twig.merge(context, innerContext, true);\n                        });\n                };\n\n                return Twig.expression.parseAsync.call(state, token.expression, context)\n                    .then(result => {\n                        if (Array.isArray(result)) {\n                            len = result.length;\n                            return Twig.async.forEach(result, value => {\n                                const key = index;\n\n                                return loop(key, value);\n                            });\n                        }\n\n                        if (Twig.lib.is('Object', result)) {\n                            if (result._keys === undefined) {\n                                keyset = Object.keys(result);\n                            } else {\n                                keyset = result._keys;\n                            }\n\n                            len = keyset.length;\n                            return Twig.async.forEach(keyset, key => {\n                            // Ignore the _keys property, it's internal to twig.js\n                                if (key === '_keys') {\n                                    return;\n                                }\n\n                                return loop(key, result[key]);\n                            });\n                        }\n                    })\n                    .then(() => {\n                    // Only allow else statements if no output was generated\n                        continueChain = (output.length === 0);\n\n                        return {\n                            chain: continueChain,\n                            context,\n                            output: Twig.output.call(state.template, output)\n                        };\n                    });\n            }\n        },\n        {\n            /**\n             * End for type logic tokens.\n             *\n             *  Format: {% endfor %}\n             */\n            type: Twig.logic.type.endfor,\n            regex: /^endfor$/,\n            next: [],\n            open: false\n        },\n        {\n            /**\n             * Set type logic tokens.\n             *\n             *  Format: {% set key = expression %}\n             */\n            type: Twig.logic.type.set,\n            regex: /^set\\s+([a-zA-Z0-9_,\\s]+)\\s*=\\s*([\\s\\S]+)$/,\n            next: [],\n            open: true,\n            compile(token) { //\n                const key = token.match[1].trim();\n                const expression = token.match[2];\n                // Compile the expression.\n                const expressionStack = Twig.expression.compile.call(this, {\n                    type: Twig.expression.type.expression,\n                    value: expression\n                }).stack;\n\n                token.key = key;\n                token.expression = expressionStack;\n\n                delete token.match;\n                return token;\n            },\n            parse(token, context, continueChain) {\n                const {key} = token;\n                const state = this;\n\n                return Twig.expression.parseAsync.call(state, token.expression, context)\n                    .then(value => {\n                        if (value === context) {\n                        /*  If storing the context in a variable, it needs to be a clone of the current state of context.\n                            Otherwise we have a context with infinite recursion.\n                            Fixes #341\n                        */\n                            value = {...value};\n                        }\n\n                        context[key] = value;\n\n                        return {\n                            chain: continueChain,\n                            context\n                        };\n                    });\n            }\n        },\n        {\n            /**\n             * Set capture type logic tokens.\n             *\n             *  Format: {% set key %}\n             */\n            type: Twig.logic.type.setcapture,\n            regex: /^set\\s+([a-zA-Z0-9_,\\s]+)$/,\n            next: [\n                Twig.logic.type.endset\n            ],\n            open: true,\n            compile(token) {\n                const key = token.match[1].trim();\n\n                token.key = key;\n\n                delete token.match;\n                return token;\n            },\n            parse(token, context, continueChain) {\n                const state = this;\n                const {key} = token;\n\n                return state.parseAsync(token.output, context)\n                    .then(output => {\n                    // Set on both the global and local context\n                        state.context[key] = output;\n                        context[key] = output;\n\n                        return {\n                            chain: continueChain,\n                            context\n                        };\n                    });\n            }\n        },\n        {\n            /**\n             * End set type block logic tokens.\n             *\n             *  Format: {% endset %}\n             */\n            type: Twig.logic.type.endset,\n            regex: /^endset$/,\n            next: [],\n            open: false\n        },\n        {\n            /**\n             * Filter logic tokens.\n             *\n             *  Format: {% filter upper %} or {% filter lower|escape %}\n             */\n            type: Twig.logic.type.filter,\n            regex: /^filter\\s+(.+)$/,\n            next: [\n                Twig.logic.type.endfilter\n            ],\n            open: true,\n            compile(token) {\n                const expression = '|' + token.match[1].trim();\n                // Compile the expression.\n                token.stack = Twig.expression.compile.call(this, {\n                    type: Twig.expression.type.expression,\n                    value: expression\n                }).stack;\n                delete token.match;\n                return token;\n            },\n            parse(token, context, chain) {\n                const state = this;\n\n                return state.parseAsync(token.output, context)\n                    .then(output => {\n                        const stack = [{\n                            type: Twig.expression.type.string,\n                            value: output\n                        }].concat(token.stack);\n\n                        return Twig.expression.parseAsync.call(state, stack, context);\n                    })\n                    .then(output => {\n                        return {\n                            chain,\n                            output\n                        };\n                    });\n            }\n        },\n        {\n            /**\n             * End filter logic tokens.\n             *\n             *  Format: {% endfilter %}\n             */\n            type: Twig.logic.type.endfilter,\n            regex: /^endfilter$/,\n            next: [],\n            open: false\n        },\n        {\n            /**\n             * Apply logic tokens.\n             *\n             *  Format: {% apply upper %} or {% apply lower|escape %}\n             */\n            type: Twig.logic.type.apply,\n            regex: /^apply\\s+(.+)$/,\n            next: [\n                Twig.logic.type.endapply\n            ],\n            open: true,\n            compile(token) {\n                const expression = '|' + token.match[1].trim();\n                // Compile the expression.\n                token.stack = Twig.expression.compile.call(this, {\n                    type: Twig.expression.type.expression,\n                    value: expression\n                }).stack;\n                delete token.match;\n                return token;\n            },\n            parse(token, context, chain) {\n                const state = this;\n\n                return state.parseAsync(token.output, context)\n                    .then(output => {\n                        const stack = [{\n                            type: Twig.expression.type.string,\n                            value: output\n                        }].concat(token.stack);\n\n                        return Twig.expression.parseAsync.call(state, stack, context);\n                    })\n                    .then(output => {\n                        return {\n                            chain,\n                            output\n                        };\n                    });\n            }\n        },\n        {\n            /**\n             * End apply logic tokens.\n             *\n             *  Format: {% endapply %}\n             */\n            type: Twig.logic.type.endapply,\n            regex: /^endapply$/,\n            next: [],\n            open: false\n        },\n        {\n            /**\n             * Set type logic tokens.\n             *\n             *  Format: {% do expression %}\n             */\n            type: Twig.logic.type.do,\n            regex: /^do\\s+([\\S\\s]+)$/,\n            next: [],\n            open: true,\n            compile(token) { //\n                const expression = token.match[1];\n                // Compile the expression.\n                const expressionStack = Twig.expression.compile.call(this, {\n                    type: Twig.expression.type.expression,\n                    value: expression\n                }).stack;\n\n                token.expression = expressionStack;\n\n                delete token.match;\n                return token;\n            },\n            parse(token, context, continueChain) {\n                const state = this;\n\n                return Twig.expression.parseAsync.call(state, token.expression, context)\n                    .then(() => {\n                        return {\n                            chain: continueChain,\n                            context\n                        };\n                    });\n            }\n        },\n        {\n            /**\n             * Block logic tokens.\n             *\n             *  Format: {% block title %}\n             */\n            type: Twig.logic.type.block,\n            regex: /^block\\s+(\\w+)$/,\n            next: [\n                Twig.logic.type.endblock\n            ],\n            open: true,\n            compile(token) {\n                token.blockName = token.match[1].trim();\n                delete token.match;\n\n                return token;\n            },\n            parse(token, context, chain) {\n                const state = this;\n                let promise = Twig.Promise.resolve();\n\n                state.template.blocks.defined[token.blockName] = new Twig.Block(state.template, token);\n\n                if (\n                    state.template.parentTemplate === null ||\n                    state.template.parentTemplate instanceof Twig.Template\n                ) {\n                    promise = state.getBlock(token.blockName).render(state, context);\n                }\n\n                return promise.then(output => {\n                    return {\n                        chain,\n                        output\n                    };\n                });\n            }\n        },\n        {\n            /**\n             * Block shorthand logic tokens.\n             *\n             *  Format: {% block title expression %}\n             */\n            type: Twig.logic.type.shortblock,\n            regex: /^block\\s+(\\w+)\\s+(.+)$/,\n            next: [],\n            open: true,\n            compile(token) {\n                const template = this;\n\n                token.expression = token.match[2].trim();\n                token.output = Twig.expression.compile({\n                    type: Twig.expression.type.expression,\n                    value: token.expression\n                }).stack;\n\n                return Twig.logic.handler[Twig.logic.type.block].compile.apply(template, [token]);\n            },\n            parse(...args) {\n                const state = this;\n\n                return Twig.logic.handler[Twig.logic.type.block].parse.apply(state, args);\n            }\n        },\n        {\n            /**\n             * End block logic tokens.\n             *\n             *  Format: {% endblock %}\n             */\n            type: Twig.logic.type.endblock,\n            regex: /^endblock(?:\\s+(\\w+))?$/,\n            next: [],\n            open: false\n        },\n        {\n            /**\n             * Block logic tokens.\n             *\n             *  Format: {% extends \"template.twig\" %}\n             */\n            type: Twig.logic.type.extends_,\n            regex: /^extends\\s+(.+)$/,\n            next: [],\n            open: true,\n            compile(token) {\n                const expression = token.match[1].trim();\n                delete token.match;\n\n                token.stack = Twig.expression.compile.call(this, {\n                    type: Twig.expression.type.expression,\n                    value: expression\n                }).stack;\n\n                return token;\n            },\n            parse(token, context, chain) {\n                const state = this;\n\n                return Twig.expression.parseAsync.call(state, token.stack, context)\n                    .then(fileName => {\n                        if (Array.isArray(fileName)) {\n                            const result = fileName.reverse().reduce((acc, file) => {\n                                try {\n                                    return {\n                                        render: state.template.importFile(file),\n                                        fileName: file\n                                    };\n                                    /* eslint-disable-next-line no-unused-vars */\n                                } catch (error) {\n                                    return acc;\n                                }\n                            }, {\n                                render: null,\n                                fileName: null\n                            });\n                            if (result.fileName !== null) {\n                                state.template.parentTemplate = result.fileName;\n                            }\n                        } else {\n                            state.template.parentTemplate = fileName;\n                        }\n\n                        return {\n                            chain,\n                            output: ''\n                        };\n                    });\n            }\n        },\n        {\n            /**\n             * Block logic tokens.\n             *\n             *  Format: {% use \"template.twig\" %}\n             */\n            type: Twig.logic.type.use,\n            regex: /^use\\s+(.+)$/,\n            next: [],\n            open: true,\n            compile(token) {\n                const expression = token.match[1].trim();\n                delete token.match;\n\n                token.stack = Twig.expression.compile.call(this, {\n                    type: Twig.expression.type.expression,\n                    value: expression\n                }).stack;\n\n                return token;\n            },\n            parse(token, context, chain) {\n                const state = this;\n\n                return Twig.expression.parseAsync.call(state, token.stack, context)\n                    .then(filePath => {\n                        // Create a new state instead of using the current state\n                        // any defined blocks will be created in isolation\n\n                        const useTemplate = state.template.importFile(filePath);\n\n                        const useState = new Twig.ParseState(useTemplate);\n                        return useState.parseAsync(useTemplate.tokens)\n                            .then(() => {\n                                state.template.blocks.imported = {\n                                    ...state.template.blocks.imported,\n                                    ...useState.getBlocks()\n                                };\n                            });\n                    })\n                    .then(() => {\n                        return {\n                            chain,\n                            output: ''\n                        };\n                    });\n            }\n        },\n        {\n            /**\n             * Block logic tokens.\n             *\n             *  Format: {% includes \"template.twig\" [with {some: 'values'} only] %}\n             */\n            type: Twig.logic.type.include,\n            regex: /^include\\s+(.+?)(?:\\s|$)(ignore missing(?:\\s|$))?(?:with\\s+([\\S\\s]+?))?(?:\\s|$)(only)?$/,\n            next: [],\n            open: true,\n            compile(token) {\n                const {match} = token;\n                const expression = match[1].trim();\n                const ignoreMissing = match[2] !== undefined;\n                const withContext = match[3];\n                const only = ((match[4] !== undefined) && match[4].length);\n\n                delete token.match;\n\n                token.only = only;\n                token.ignoreMissing = ignoreMissing;\n\n                token.stack = Twig.expression.compile.call(this, {\n                    type: Twig.expression.type.expression,\n                    value: expression\n                }).stack;\n\n                if (withContext !== undefined) {\n                    token.withStack = Twig.expression.compile.call(this, {\n                        type: Twig.expression.type.expression,\n                        value: withContext.trim()\n                    }).stack;\n                }\n\n                return token;\n            },\n            parse(token, context, chain) {\n                // Resolve filename\n                let innerContext = token.only ? {} : {...context};\n                const {ignoreMissing} = token;\n                const state = this;\n                let promise = null;\n                const result = {chain, output: ''};\n\n                if (typeof token.withStack === 'undefined') {\n                    promise = Twig.Promise.resolve();\n                } else {\n                    promise = Twig.expression.parseAsync.call(state, token.withStack, context)\n                        .then(withContext => {\n                            innerContext = {\n                                ...innerContext,\n                                ...withContext\n                            };\n                        });\n                }\n\n                return promise\n                    .then(() => {\n                        return Twig.expression.parseAsync.call(state, token.stack, context);\n                    })\n                    .then(file => {\n                        let files;\n                        if (Array.isArray(file)) {\n                            files = file;\n                        } else {\n                            files = [file];\n                        }\n\n                        const result = files.reduce((acc, file) => {\n                            if (acc.render === null) {\n                                if (file instanceof Twig.Template) {\n                                    return {\n                                        render: file.renderAsync(\n                                            innerContext,\n                                            {\n                                                isInclude: true\n                                            }\n                                        ),\n                                        lastError: null\n                                    };\n                                }\n\n                                try {\n                                    return {\n                                        render: state.template.importFile(file).renderAsync(\n                                            innerContext,\n                                            {\n                                                isInclude: true\n                                            }\n                                        ),\n                                        lastError: null\n                                    };\n                                } catch (error) {\n                                    return {\n                                        render: null,\n                                        lastError: error\n                                    };\n                                }\n                            }\n\n                            return acc;\n                        }, {render: null, lastError: null});\n\n                        if (result.render !== null) {\n                            return result.render;\n                        }\n\n                        if (result.render === null && ignoreMissing) {\n                            return '';\n                        }\n\n                        throw result.lastError;\n                    })\n                    .then(output => {\n                        if (output !== '') {\n                            result.output = output;\n                        }\n\n                        return result;\n                    });\n            }\n        },\n        {\n            type: Twig.logic.type.spaceless,\n            regex: /^spaceless$/,\n            next: [\n                Twig.logic.type.endspaceless\n            ],\n            open: true,\n\n            // Parse the html and return it without any spaces between tags\n            parse(token, context, chain) {\n                const state = this;\n\n                // Parse the output without any filter\n                return state.parseAsync(token.output, context)\n                    .then(tokenOutput => {\n                        const // A regular expression to find closing and opening tags with spaces between them\n                            rBetweenTagSpaces = />\\s+</g;\n                        // Replace all space between closing and opening html tags\n                        let output = tokenOutput.replace(rBetweenTagSpaces, '><').trim();\n                        // Rewrap output as a Twig.Markup\n                        output = new Twig.Markup(output);\n                        return {\n                            chain,\n                            output\n                        };\n                    });\n            }\n        },\n\n        // Add the {% endspaceless %} token\n        {\n            type: Twig.logic.type.endspaceless,\n            regex: /^endspaceless$/,\n            next: [],\n            open: false\n        },\n        {\n            /**\n             * Macro logic tokens.\n             *\n             * Format: {% macro input(name = default, value, type, size) %}\n             *\n             */\n            type: Twig.logic.type.macro,\n            regex: /^macro\\s+(\\w+)\\s*\\(\\s*((?:\\w+(?:\\s*=\\s*([\\s\\S]+))?(?:,\\s*)?)*)\\s*\\)$/,\n            next: [\n                Twig.logic.type.endmacro\n            ],\n            open: true,\n            compile(token) {\n                const macroName = token.match[1];\n                const rawParameters = token.match[2].split(/\\s*,\\s*/);\n                const parameters = rawParameters.map(rawParameter => {\n                    return rawParameter.split(/\\s*=\\s*/)[0];\n                });\n                const parametersCount = parameters.length;\n\n                // Duplicate check\n                if (parametersCount > 1) {\n                    const uniq = {};\n                    for (let i = 0; i < parametersCount; i++) {\n                        const parameter = parameters[i];\n                        if (uniq[parameter]) {\n                            throw new Twig.Error('Duplicate arguments for parameter: ' + parameter);\n                        } else {\n                            uniq[parameter] = 1;\n                        }\n                    }\n                }\n\n                token.macroName = macroName;\n                token.parameters = parameters;\n                token.defaults = rawParameters.reduce(function (defaults, rawParameter) {\n                    const pair = rawParameter.split(/\\s*=\\s*/);\n                    const key = pair[0];\n                    const expression = pair[1];\n\n                    if (expression) {\n                        defaults[key] = Twig.expression.compile.call(this, {\n                            type: Twig.expression.type.expression,\n                            value: expression\n                        }).stack;\n                    } else {\n                        defaults[key] = undefined;\n                    }\n\n                    return defaults;\n                }, {});\n\n                delete token.match;\n                return token;\n            },\n            parse(token, context, chain) {\n                const state = this;\n\n                state.macros[token.macroName] = function (...args) {\n                    // Pass global context and other macros\n                    const macroContext = {\n                        ...context,\n                        _self: state.macros\n                    };\n                    // Save arguments\n\n                    return Twig.async.forEach(token.parameters, function (prop, i) {\n                        // Add parameters from context to macroContext\n                        if (typeof args[i] !== 'undefined') {\n                            macroContext[prop] = args[i];\n                            return true;\n                        }\n\n                        if (typeof token.defaults[prop] !== 'undefined') {\n                            return Twig.expression.parseAsync.call(this, token.defaults[prop], context)\n                                .then(value => {\n                                    macroContext[prop] = value;\n                                    return Twig.Promise.resolve();\n                                });\n                        }\n\n                        macroContext[prop] = undefined;\n                        return true;\n                    }).then(() => {\n                        // Render\n                        return state.parseAsync(token.output, macroContext);\n                    });\n                };\n\n                return {\n                    chain,\n                    output: ''\n                };\n            }\n        },\n        {\n            /**\n             * End macro logic tokens.\n             *\n             * Format: {% endmacro %}\n             */\n            type: Twig.logic.type.endmacro,\n            regex: /^endmacro$/,\n            next: [],\n            open: false\n        },\n        {\n            /*\n            * Import logic tokens.\n            *\n            * Format: {% import \"template.twig\" as form %}\n            */\n            type: Twig.logic.type.import_,\n            regex: /^import\\s+(.+)\\s+as\\s+(\\w+)$/,\n            next: [],\n            open: true,\n            compile(token) {\n                const expression = token.match[1].trim();\n                const contextName = token.match[2].trim();\n                delete token.match;\n\n                token.expression = expression;\n                token.contextName = contextName;\n\n                token.stack = Twig.expression.compile.call(this, {\n                    type: Twig.expression.type.expression,\n                    value: expression\n                }).stack;\n\n                return token;\n            },\n            parse(token, context, chain) {\n                const state = this;\n                const output = {\n                    chain,\n                    output: ''\n                };\n\n                if (token.expression === '_self') {\n                    context[token.contextName] = state.macros;\n                    return output;\n                }\n\n                return Twig.expression.parseAsync.call(state, token.stack, context)\n                    .then(filePath => {\n                        return state.template.importFile(filePath || token.expression);\n                    })\n                    .then(importTemplate => {\n                        const importState = new Twig.ParseState(importTemplate);\n\n                        return importState.parseAsync(importTemplate.tokens).then(() => {\n                            context[token.contextName] = importState.macros;\n\n                            return output;\n                        });\n                    });\n            }\n        },\n        {\n            /*\n            * From logic tokens.\n            *\n            * Format: {% from \"template.twig\" import func as form %}\n            */\n            type: Twig.logic.type.from,\n            regex: /^from\\s+(.+)\\s+import\\s+([a-zA-Z0-9_, ]+)$/,\n            next: [],\n            open: true,\n            compile(token) {\n                const expression = token.match[1].trim();\n                const macroExpressions = token.match[2].trim().split(/\\s*,\\s*/);\n                const macroNames = {};\n\n                for (const res of macroExpressions) {\n                    // Match function as variable\n                    const macroMatch = res.match(/^(\\w+)\\s+as\\s+(\\w+)$/);\n                    if (macroMatch) {\n                        macroNames[macroMatch[1].trim()] = macroMatch[2].trim();\n                    } else if (res.match(/^(\\w+)$/)) {\n                        macroNames[res] = res;\n                    } else {\n                        // ignore import\n                    }\n                }\n\n                delete token.match;\n\n                token.expression = expression;\n                token.macroNames = macroNames;\n\n                token.stack = Twig.expression.compile.call(this, {\n                    type: Twig.expression.type.expression,\n                    value: expression\n                }).stack;\n\n                return token;\n            },\n            parse(token, context, chain) {\n                const state = this;\n                let promise;\n\n                if (token.expression === '_self') {\n                    promise = Twig.Promise.resolve(state.macros);\n                } else {\n                    promise = Twig.expression.parseAsync.call(state, token.stack, context)\n                        .then(filePath => {\n                            return state.template.importFile(filePath || token.expression);\n                        })\n                        .then(importTemplate => {\n                            const importState = new Twig.ParseState(importTemplate);\n\n                            return importState.parseAsync(importTemplate.tokens).then(() => {\n                                return importState.macros;\n                            });\n                        });\n                }\n\n                return promise\n                    .then(macros => {\n                        for (const macroName in token.macroNames) {\n                            if (macros[macroName] !== undefined) {\n                                context[token.macroNames[macroName]] = macros[macroName];\n                            }\n                        }\n\n                        return {\n                            chain,\n                            output: ''\n                        };\n                    });\n            }\n        },\n        {\n            /**\n             * The embed tag combines the behaviour of include and extends.\n             * It allows you to include another template's contents, just like include does.\n             *\n             *  Format: {% embed \"template.twig\" [with {some: 'values'} only] %}\n             */\n            type: Twig.logic.type.embed,\n            regex: /^embed\\s+(.+?)(?:\\s+(ignore missing))?(?:\\s+with\\s+([\\S\\s]+?))?(?:\\s+(only))?$/,\n            next: [\n                Twig.logic.type.endembed\n            ],\n            open: true,\n            compile(token) {\n                const {match} = token;\n                const expression = match[1].trim();\n                const ignoreMissing = match[2] !== undefined;\n                const withContext = match[3];\n                const only = ((match[4] !== undefined) && match[4].length);\n\n                delete token.match;\n\n                token.only = only;\n                token.ignoreMissing = ignoreMissing;\n\n                token.stack = Twig.expression.compile.call(this, {\n                    type: Twig.expression.type.expression,\n                    value: expression\n                }).stack;\n\n                if (withContext !== undefined) {\n                    token.withStack = Twig.expression.compile.call(this, {\n                        type: Twig.expression.type.expression,\n                        value: withContext.trim()\n                    }).stack;\n                }\n\n                return token;\n            },\n            parse(token, context, chain) {\n                let embedContext = {};\n                let promise = Twig.Promise.resolve();\n                let state = this;\n\n                if (!token.only) {\n                    embedContext = {...context};\n                }\n\n                if (token.withStack !== undefined) {\n                    promise = Twig.expression.parseAsync.call(state, token.withStack, context).then(withContext => {\n                        embedContext = {...embedContext, ...withContext};\n                    });\n                }\n\n                return promise\n                    .then(() => {\n                        return Twig.expression.parseAsync.call(state, token.stack, embedContext);\n                    })\n                    .then(fileName => {\n                        const embedOverrideTemplate = new Twig.Template({\n                            data: token.output,\n                            id: state.template.id,\n                            base: state.template.base,\n                            path: state.template.path,\n                            url: state.template.url,\n                            name: state.template.name,\n                            method: state.template.method,\n                            options: state.template.options\n                        });\n\n                        try {\n                            embedOverrideTemplate.importFile(fileName);\n                        } catch (error) {\n                            if (token.ignoreMissing) {\n                                return '';\n                            }\n\n                            // Errors preserve references to variables in scope,\n                            // this removes `this` from the scope.\n                            state = null;\n\n                            throw error;\n                        }\n\n                        embedOverrideTemplate.parentTemplate = fileName;\n\n                        return embedOverrideTemplate.renderAsync(\n                            embedContext,\n                            {\n                                isInclude: true\n                            }\n                        );\n                    })\n                    .then(output => {\n                        return {\n                            chain,\n                            output\n                        };\n                    });\n            }\n        },\n        /* Add the {% endembed %} token\n         *\n         */\n        {\n            type: Twig.logic.type.endembed,\n            regex: /^endembed$/,\n            next: [],\n            open: false\n        },\n        {\n            /**\n             * Block logic tokens.\n             *\n             *  Format: {% with {some: 'values'} [only] %}\n             */\n            type: Twig.logic.type.with,\n            regex: /^(?:with\\s+([\\S\\s]+?))(?:\\s|$)(only)?$/,\n            next: [\n                Twig.logic.type.endwith\n            ],\n            open: true,\n            compile(token) {\n                const {match} = token;\n                const withContext = match[1];\n                const only = ((match[2] !== undefined) && match[2].length);\n\n                delete token.match;\n\n                token.only = only;\n\n                if (withContext !== undefined) {\n                    token.withStack = Twig.expression.compile.call(this, {\n                        type: Twig.expression.type.expression,\n                        value: withContext.trim()\n                    }).stack;\n                }\n\n                return token;\n            },\n            parse(token, context, chain) {\n                // Resolve filename\n                let innerContext = {};\n                let i;\n                const state = this;\n                let promise = Twig.Promise.resolve();\n\n                if (!token.only) {\n                    innerContext = {...context};\n                }\n\n                if (token.withStack !== undefined) {\n                    promise = Twig.expression.parseAsync.call(state, token.withStack, context)\n                        .then(withContext => {\n                            for (i in withContext) {\n                                if (Object.hasOwnProperty.call(withContext, i)) {\n                                    innerContext[i] = withContext[i];\n                                }\n                            }\n                        });\n                }\n\n                return promise\n                    .then(() => {\n                        return state.parseAsync(token.output, innerContext);\n                    })\n                    .then(output => {\n                        return {\n                            chain,\n                            output\n                        };\n                    });\n            }\n        },\n        {\n            type: Twig.logic.type.endwith,\n            regex: /^endwith$/,\n            next: [],\n            open: false\n        },\n        {\n            /**\n             * Deprecated type logic tokens.\n             *\n             *  Format: {% deprecated 'Description' %}\n             */\n            type: Twig.logic.type.deprecated,\n            regex: /^deprecated\\s+(.+)$/,\n            next: [],\n            open: true,\n            compile(token) {\n                console.warn('Deprecation notice: ' + token.match[1]);\n\n                return token;\n            },\n            parse() {\n                return {};\n            }\n        }\n\n    ];\n\n    /**\n     * Registry for logic handlers.\n     */\n    Twig.logic.handler = {};\n\n    /**\n     * Define a new token type, available at Twig.logic.type.{type}\n     */\n    Twig.logic.extendType = function (type, value) {\n        value = value || ('Twig.logic.type' + type);\n        Twig.logic.type[type] = value;\n    };\n\n    /**\n     * Extend the logic parsing functionality with a new token definition.\n     *\n     * // Define a new tag\n     * Twig.logic.extend({\n     *     type: Twig.logic.type.{type},\n     *     // The pattern to match for this token\n     *     regex: ...,\n     *     // What token types can follow this token, leave blank if any.\n     *     next: [ ... ]\n     *     // Create and return compiled version of the token\n     *     compile: function(token) { ... }\n     *     // Parse the compiled token with the context provided by the render call\n     *     //   and whether this token chain is complete.\n     *     parse: function(token, context, chain) { ... }\n     * });\n     *\n     * @param {Object} definition The new logic expression.\n     */\n    Twig.logic.extend = function (definition) {\n        if (definition.type) {\n            Twig.logic.extendType(definition.type);\n        } else {\n            throw new Twig.Error('Unable to extend logic definition. No type provided for ' + definition);\n        }\n\n        Twig.logic.handler[definition.type] = definition;\n    };\n\n    // Extend with built-in expressions\n    while (Twig.logic.definitions.length > 0) {\n        Twig.logic.extend(Twig.logic.definitions.shift());\n    }\n\n    /**\n     * Compile a logic token into an object ready for parsing.\n     *\n     * @param {Object} rawToken An uncompiled logic token.\n     *\n     * @return {Object} A compiled logic token, ready for parsing.\n     */\n    Twig.logic.compile = function (rawToken) {\n        const expression = rawToken.value.trim();\n        let token = Twig.logic.tokenize.call(this, expression);\n        const tokenTemplate = Twig.logic.handler[token.type];\n\n        // Check if the token needs compiling\n        if (tokenTemplate.compile) {\n            token = tokenTemplate.compile.call(this, token);\n            Twig.log.trace('Twig.logic.compile: ', 'Compiled logic token to ', token);\n        }\n\n        return token;\n    };\n\n    /**\n     * Tokenize logic expressions. This function matches token expressions against regular\n     * expressions provided in token definitions provided with Twig.logic.extend.\n     *\n     * @param {string} expression the logic token expression to tokenize\n     *                (i.e. what's between {% and %})\n     *\n     * @return {Object} The matched token with type set to the token type and match to the regex match.\n     */\n    Twig.logic.tokenize = function (expression) {\n        let tokenTemplateType = null;\n        let tokenType = null;\n        let tokenRegex = null;\n        let regexArray = null;\n        let regexLen = null;\n        let regexI = null;\n        let match = null;\n\n        // Ignore whitespace around expressions.\n        expression = expression.trim();\n\n        for (tokenTemplateType in Twig.logic.handler) {\n            if (Object.hasOwnProperty.call(Twig.logic.handler, tokenTemplateType)) {\n                // Get the type and regex for this template type\n                tokenType = Twig.logic.handler[tokenTemplateType].type;\n                tokenRegex = Twig.logic.handler[tokenTemplateType].regex;\n\n                // Handle multiple regular expressions per type.\n                regexArray = tokenRegex;\n                if (!Array.isArray(tokenRegex)) {\n                    regexArray = [tokenRegex];\n                }\n\n                regexLen = regexArray.length;\n                // Check regular expressions in the order they were specified in the definition.\n                for (regexI = 0; regexI < regexLen; regexI++) {\n                    match = regexArray[regexI].exec(expression);\n                    if (match !== null) {\n                        Twig.log.trace('Twig.logic.tokenize: ', 'Matched a ', tokenType, ' regular expression of ', match);\n                        return {\n                            type: tokenType,\n                            match\n                        };\n                    }\n                }\n            }\n        }\n\n        // No regex matches\n        throw new Twig.Error('Unable to parse \\'' + expression.trim() + '\\'');\n    };\n\n    /**\n     * Parse a logic token within a given context.\n     *\n     * What are logic chains?\n     *      Logic chains represent a series of tokens that are connected,\n     *          for example:\n     *          {% if ... %} {% else %} {% endif %}\n     *\n     *      The chain parameter is used to signify if a chain is open of closed.\n     *      open:\n     *          More tokens in this chain should be parsed.\n     *      closed:\n     *          This token chain has completed parsing and any additional\n     *          tokens (else, elseif, etc...) should be ignored.\n     *\n     * @param {Object} token The compiled token.\n     * @param {Object} context The render context.\n     * @param {boolean} chain Is this an open logic chain. If false, that means a\n     *                        chain is closed and no further cases should be parsed.\n     */\n    Twig.logic.parse = function (token, context, chain, allowAsync) {\n        return Twig.async.potentiallyAsync(this, allowAsync, function () {\n            Twig.log.debug('Twig.logic.parse: ', 'Parsing logic token ', token);\n\n            const tokenTemplate = Twig.logic.handler[token.type];\n            let result;\n            const state = this;\n\n            if (!tokenTemplate.parse) {\n                return '';\n            }\n\n            state.nestingStack.unshift(token);\n            result = tokenTemplate.parse.call(state, token, context || {}, chain);\n\n            if (Twig.isPromise(result)) {\n                result = result.then(result => {\n                    state.nestingStack.shift();\n\n                    return result;\n                });\n            } else {\n                state.nestingStack.shift();\n            }\n\n            return result;\n        });\n    };\n\n    return Twig;\n};\n","module.exports = function (Twig) {\n    'use strict';\n\n    Twig.Templates.registerParser('source', params => {\n        return params.data || '';\n    });\n};\n","module.exports = function (Twig) {\n    'use strict';\n\n    Twig.Templates.registerParser('twig', params => {\n        return new Twig.Template(params);\n    });\n};\n","// ## twig.path.js\n//\n// This file handles path parsing\nmodule.exports = function (Twig) {\n    'use strict';\n\n    /**\n     * Namespace for path handling.\n     */\n    Twig.path = {};\n\n    /**\n     * Generate the canonical version of a url based on the given base path and file path and in\n     * the previously registered namespaces.\n     *\n     * @param  {string} template The Twig Template\n     * @param  {string} _file    The file path, may be relative and may contain namespaces.\n     *\n     * @return {string}          The canonical version of the path\n     */\n    Twig.path.parsePath = function (template, _file) {\n        let k = null;\n        const {namespaces} = template.options;\n        let file = _file || '';\n        const hasNamespaces = namespaces && typeof namespaces === 'object';\n\n        if (hasNamespaces) {\n            for (k in namespaces) {\n                if (!file.includes(k)) {\n                    continue;\n                }\n\n                // Check if keyed namespace exists at path's start\n                const colon = new RegExp('^' + k + '::');\n                const atSign = new RegExp('^@' + k + '/');\n                // Add slash to the end of path\n                const namespacePath = namespaces[k].replace(/([^/])$/, '$1/');\n\n                if (colon.test(file)) {\n                    file = file.replace(colon, namespacePath);\n                    return file;\n                }\n\n                if (atSign.test(file)) {\n                    file = file.replace(atSign, namespacePath);\n                    return file;\n                }\n            }\n        }\n\n        return Twig.path.relativePath(template, file);\n    };\n\n    /**\n     * Generate the relative canonical version of a url based on the given base path and file path.\n     *\n     * @param {Twig.Template} template The Twig.Template.\n     * @param {string} _file The file path, relative to the base path.\n     *\n     * @return {string} The canonical version of the path.\n     */\n    Twig.path.relativePath = function (template, _file) {\n        let base;\n        let basePath;\n        let sepChr = '/';\n        const newPath = [];\n        let file = _file || '';\n        let val;\n\n        if (template.url) {\n            if (typeof template.base === 'undefined') {\n                base = template.url;\n            } else {\n                // Add slash to the end of path\n                base = template.base.replace(/([^/])$/, '$1/');\n            }\n        } else if (template.path) {\n            // Get the system-specific path separator\n            const path = require('path');\n            const sep = path.sep || sepChr;\n            const relative = new RegExp('^\\\\.{1,2}' + sep.replace('\\\\', '\\\\\\\\'));\n            file = file.replace(/\\//g, sep);\n\n            if (template.base !== undefined && file.match(relative) === null) {\n                file = file.replace(template.base, '');\n                base = template.base + sep;\n            } else {\n                base = path.normalize(template.path);\n            }\n\n            base = base.replace(sep + sep, sep);\n            sepChr = sep;\n        } else if ((template.name || template.id) && template.method && template.method !== 'fs' && template.method !== 'ajax') {\n            // Custom registered loader\n            base = template.base || template.name || template.id;\n        } else {\n            throw new Twig.Error('Cannot extend an inline template.');\n        }\n\n        basePath = base.split(sepChr);\n\n        // Remove file from url\n        basePath.pop();\n        basePath = basePath.concat(file.split(sepChr));\n\n        while (basePath.length > 0) {\n            val = basePath.shift();\n            if (val === '.') {\n                // Ignore\n            } else if (val === '..' && newPath.length > 0 && newPath[newPath.length - 1] !== '..') {\n                newPath.pop();\n            } else {\n                newPath.push(val);\n            }\n        }\n\n        return newPath.join(sepChr);\n    };\n\n    return Twig;\n};\n","// ## twig.tests.js\n//\n// This file handles expression tests. (is empty, is not defined, etc...)\nmodule.exports = function (Twig) {\n    'use strict';\n    Twig.tests = {\n        empty(value) {\n            if (value === null || value === undefined) {\n                return true;\n            }\n\n            // Handler numbers\n            if (typeof value === 'number') {\n                return false;\n            } // Numbers are never \"empty\"\n\n            // Handle strings and arrays\n            if (value.length > 0) {\n                return false;\n            }\n\n            // Handle objects\n            for (const key in value) {\n                if (Object.hasOwnProperty.call(value, key)) {\n                    return false;\n                }\n            }\n\n            return true;\n        },\n        odd(value) {\n            return value % 2 === 1;\n        },\n        even(value) {\n            return value % 2 === 0;\n        },\n        divisibleby(value, params) {\n            return value % params[0] === 0;\n        },\n        defined(value) {\n            return value !== undefined;\n        },\n        none(value) {\n            return value === null;\n        },\n        null(value) {\n            return this.none(value); // Alias of none\n        },\n        'same as'(value, params) {\n            return value === params[0];\n        },\n        sameas(value, params) {\n            console.warn('`sameas` is deprecated use `same as`');\n            return Twig.tests['same as'](value, params);\n        },\n        iterable(value) {\n            return value && (Twig.lib.is('Array', value) || Twig.lib.is('Object', value));\n        }\n        /*\n        Constant ?\n         */\n    };\n\n    Twig.test = function (test, value, params) {\n        if (!Twig.tests[test]) {\n            throw Twig.Error('Test ' + test + ' is not defined.');\n        }\n\n        return Twig.tests[test](value, params);\n    };\n\n    Twig.test.extend = function (test, definition) {\n        Twig.tests[test] = definition;\n    };\n\n    return Twig;\n};\n","// ## twig.async.js\n//\n// This file handles asynchronous tasks within twig.\nmodule.exports = function (Twig) {\n    'use strict';\n\n    const STATE_UNKNOWN = 0;\n    const STATE_RESOLVED = 1;\n    const STATE_REJECTED = 2;\n\n    Twig.ParseState.prototype.parseAsync = function (tokens, context) {\n        return this.parse(tokens, context, true);\n    };\n\n    Twig.expression.parseAsync = function (tokens, context, tokensAreParameters) {\n        const state = this;\n\n        return Twig.expression.parse.call(state, tokens, context, tokensAreParameters, true);\n    };\n\n    Twig.logic.parseAsync = function (token, context, chain) {\n        const state = this;\n\n        return Twig.logic.parse.call(state, token, context, chain, true);\n    };\n\n    Twig.Template.prototype.renderAsync = function (context, params) {\n        return this.render(context, params, true);\n    };\n\n    Twig.async = {};\n\n    /**\n     * Checks for `thenable` objects\n     */\n    Twig.isPromise = function (obj) {\n        return obj && obj.then && (typeof obj.then === 'function');\n    };\n\n    /**\n     * Handling of code paths that might either return a promise\n     * or a value depending on whether async code is used.\n     *\n     * @see https://github.com/twigjs/twig.js/blob/master/ASYNC.md#detecting-asynchronous-behaviour\n     */\n    function potentiallyAsyncSlow(that, allowAsync, action) {\n        let result = action.call(that);\n        let err = null;\n        let isAsync = true;\n\n        if (!Twig.isPromise(result)) {\n            return result;\n        }\n\n        result.then(res => {\n            result = res;\n            isAsync = false;\n        }).catch(error => {\n            err = error;\n        });\n\n        if (err !== null) {\n            throw err;\n        }\n\n        if (isAsync) {\n            throw new Twig.Error('You are using Twig.js in sync mode in combination with async extensions.');\n        }\n\n        return result;\n    }\n\n    Twig.async.potentiallyAsync = function (that, allowAsync, action) {\n        if (allowAsync) {\n            return Twig.Promise.resolve(action.call(that));\n        }\n\n        return potentiallyAsyncSlow(that, allowAsync, action);\n    };\n\n    function run(fn, resolve, reject) {\n        try {\n            fn(resolve, reject);\n        } catch (error) {\n            reject(error);\n        }\n    }\n\n    function pending(handlers, onResolved, onRejected) {\n        const h = [onResolved, onRejected, -2];\n\n        // The promise has yet to be rejected or resolved.\n        if (!handlers) {\n            handlers = h;\n        } else if (handlers[2] === -2) {\n            // Only allocate an array when there are multiple handlers\n            handlers = [handlers, h];\n        } else {\n            handlers.push(h);\n        }\n\n        return handlers;\n    }\n\n    /**\n     * Really small thenable to represent promises that resolve immediately.\n     *\n     */\n    Twig.Thenable = function (then, value, state) {\n        this.then = then;\n        this._value = state ? value : null;\n        this._state = state || STATE_UNKNOWN;\n    };\n\n    Twig.Thenable.prototype.catch = function (onRejected) {\n        // THe promise will not throw, it has already resolved.\n        if (this._state === STATE_RESOLVED) {\n            return this;\n        }\n\n        return this.then(null, onRejected);\n    };\n\n    /**\n     * The `then` method attached to a Thenable when it has resolved.\n     *\n     */\n    Twig.Thenable.resolvedThen = function (onResolved) {\n        try {\n            return Twig.Promise.resolve(onResolved(this._value));\n        } catch (error) {\n            return Twig.Promise.reject(error);\n        }\n    };\n\n    /**\n     * The `then` method attached to a Thenable when it has rejected.\n     *\n     */\n    Twig.Thenable.rejectedThen = function (onResolved, onRejected) {\n        // Shortcut for rejected twig promises\n        if (!onRejected || typeof onRejected !== 'function') {\n            return this;\n        }\n\n        const value = this._value;\n\n        let result;\n        try {\n            result = onRejected(value);\n        } catch (error) {\n            result = Twig.Promise.reject(error);\n        }\n\n        return Twig.Promise.resolve(result);\n    };\n\n    /**\n     * An alternate implementation of a Promise that does not fully follow\n     * the spec, but instead works fully synchronous while still being\n     * thenable.\n     *\n     * These promises can be mixed with regular promises at which point\n     * the synchronous behaviour is lost.\n     */\n    Twig.Promise = function (executor) {\n        let state = STATE_UNKNOWN;\n        let value = null;\n\n        let changeState = function (nextState, nextValue) {\n            state = nextState;\n            value = nextValue;\n        };\n\n        function onReady(v) {\n            changeState(STATE_RESOLVED, v);\n        }\n\n        function onReject(e) {\n            changeState(STATE_REJECTED, e);\n        }\n\n        run(executor, onReady, onReject);\n\n        // If the promise settles right after running the executor we can\n        // return a Promise with it's state already set.\n        //\n        // Twig.Promise.resolve and Twig.Promise.reject both use the more\n        // efficient `Twig.Thenable` for this purpose.\n        if (state === STATE_RESOLVED) {\n            return Twig.Promise.resolve(value);\n        }\n\n        if (state === STATE_REJECTED) {\n            return Twig.Promise.reject(value);\n        }\n        // If we managed to get here our promise is going to resolve asynchronous.\n\n        changeState = new Twig.FullPromise();\n\n        return changeState.promise;\n    };\n\n    /**\n     * Promise implementation that can handle being resolved at any later time.\n     *\n     */\n    Twig.FullPromise = function () {\n        let handlers = null;\n\n        // The state has been changed to either resolve, or reject\n        // which means we should call the handler.\n        function resolved(onResolved) {\n            onResolved(p._value);\n        }\n\n        function rejected(onResolved, onRejected) {\n            onRejected(p._value);\n        }\n\n        let append = function (onResolved, onRejected) {\n            handlers = pending(handlers, onResolved, onRejected);\n        };\n\n        function changeState(newState, v) {\n            if (p._state) {\n                return;\n            }\n\n            p._value = v;\n            p._state = newState;\n\n            append = newState === STATE_RESOLVED ? resolved : rejected;\n\n            if (!handlers) {\n                return;\n            }\n\n            if (handlers[2] === -2) {\n                append(handlers[0], handlers[1]);\n                handlers = null;\n                return;\n            }\n\n            handlers.forEach(h => {\n                append(h[0], h[1]);\n            });\n            handlers = null;\n        }\n\n        const p = new Twig.Thenable((onResolved, onRejected) => {\n            const hasResolved = typeof onResolved === 'function';\n\n            // Shortcut for resolved twig promises\n            if (p._state === STATE_RESOLVED && !hasResolved) {\n                return Twig.Promise.resolve(p._value);\n            }\n\n            if (p._state === STATE_RESOLVED) {\n                try {\n                    return Twig.Promise.resolve(onResolved(p._value));\n                } catch (error) {\n                    return Twig.Promise.reject(error);\n                }\n            }\n\n            const hasRejected = typeof onRejected === 'function';\n\n            return new Twig.Promise((resolve, reject) => {\n                append(\n                    hasResolved ? result => {\n                        try {\n                            resolve(onResolved(result));\n                        } catch (error) {\n                            reject(error);\n                        }\n                    } : resolve,\n                    hasRejected ? err => {\n                        try {\n                            resolve(onRejected(err));\n                        } catch (error) {\n                            reject(error);\n                        }\n                    } : reject\n                );\n            });\n        });\n\n        changeState.promise = p;\n\n        return changeState;\n    };\n\n    Twig.Promise.defaultResolved = new Twig.Thenable(Twig.Thenable.resolvedThen, undefined, STATE_RESOLVED);\n    Twig.Promise.emptyStringResolved = new Twig.Thenable(Twig.Thenable.resolvedThen, '', STATE_RESOLVED);\n\n    Twig.Promise.resolve = function (value) {\n        if (arguments.length === 0 || typeof value === 'undefined') {\n            return Twig.Promise.defaultResolved;\n        }\n\n        if (Twig.isPromise(value)) {\n            return value;\n        }\n\n        // Twig often resolves with an empty string, we optimize for this\n        // scenario by returning a fixed promise. This reduces the load on\n        // garbage collection.\n        if (value === '') {\n            return Twig.Promise.emptyStringResolved;\n        }\n\n        return new Twig.Thenable(Twig.Thenable.resolvedThen, value, STATE_RESOLVED);\n    };\n\n    Twig.Promise.reject = function (e) {\n        // `e` should never be a promise.\n        return new Twig.Thenable(Twig.Thenable.rejectedThen, e, STATE_REJECTED);\n    };\n\n    Twig.Promise.all = function (promises) {\n        const results = new Array(promises.length);\n\n        return Twig.async.forEach(promises, (p, index) => {\n            if (!Twig.isPromise(p)) {\n                results[index] = p;\n                return;\n            }\n\n            if (p._state === STATE_RESOLVED) {\n                results[index] = p._value;\n                return;\n            }\n\n            return p.then(v => {\n                results[index] = v;\n            });\n        }).then(() => {\n            return results;\n        });\n    };\n\n    /**\n    * Go over each item in a fashion compatible with Twig.forEach,\n    * allow the function to return a promise or call the third argument\n    * to signal it is finished.\n    *\n    * Each item in the array will be called sequentially.\n    */\n    Twig.async.forEach = function (arr, callback) {\n        const len = arr ? arr.length : 0;\n        let index = 0;\n\n        function next() {\n            let resp = null;\n\n            do {\n                if (index === len) {\n                    return Twig.Promise.resolve();\n                }\n\n                resp = callback(arr[index], index);\n                index++;\n\n            // While the result of the callback is not a promise or it is\n            // a promise that has settled we can use a regular loop which\n            // is much faster.\n            } while (!resp || !Twig.isPromise(resp) || resp._state === STATE_RESOLVED);\n\n            return resp.then(next);\n        }\n\n        return next();\n    };\n\n    return Twig;\n};\n","// ## twig.exports.js\n//\n// This file provides extension points and other hooks into the twig functionality.\n\nmodule.exports = function (Twig) {\n    'use strict';\n    Twig.exports = {\n        VERSION: Twig.VERSION\n    };\n\n    /**\n     * Create and compile a twig.js template.\n     *\n     * @param {Object} param Paramteres for creating a Twig template.\n     *\n     * @return {Twig.Template} A Twig template ready for rendering.\n     */\n    Twig.exports.twig = function (params) {\n        'use strict';\n        const {id} = params;\n        const options = {\n            strictVariables: params.strict_variables || false,\n            // TODO: turn autoscape on in the next major version\n            autoescape: (params.autoescape !== null && params.autoescape) || false,\n            allowInlineIncludes: params.allowInlineIncludes || false,\n            rethrow: params.rethrow || false,\n            namespaces: params.namespaces\n        };\n\n        if (Twig.cache && id) {\n            Twig.validateId(id);\n        }\n\n        if (params.debug !== undefined) {\n            Twig.debug = params.debug;\n        }\n\n        if (params.trace !== undefined) {\n            Twig.trace = params.trace;\n        }\n\n        if (params.data !== undefined) {\n            return Twig.Templates.parsers.twig({\n                data: params.data,\n                path: Object.hasOwnProperty.call(params, 'path') ? params.path : undefined,\n                module: params.module,\n                id,\n                options\n            });\n        }\n\n        if (params.ref !== undefined) {\n            if (params.id !== undefined) {\n                throw new Twig.Error('Both ref and id cannot be set on a twig.js template.');\n            }\n\n            return Twig.Templates.load(params.ref);\n        }\n\n        if (params.method !== undefined) {\n            if (!Twig.Templates.isRegisteredLoader(params.method)) {\n                throw new Twig.Error('Loader for \"' + params.method + '\" is not defined.');\n            }\n\n            return Twig.Templates.loadRemote(params.name || params.href || params.path || id || undefined, {\n                id,\n                method: params.method,\n                parser: params.parser || 'twig',\n                base: params.base,\n                module: params.module,\n                precompiled: params.precompiled,\n                async: params.async,\n                options\n\n            }, params.load, params.error);\n        }\n\n        if (params.href !== undefined) {\n            return Twig.Templates.loadRemote(params.href, {\n                id,\n                method: 'ajax',\n                parser: params.parser || 'twig',\n                base: params.base,\n                module: params.module,\n                precompiled: params.precompiled,\n                async: params.async,\n                options\n\n            }, params.load, params.error);\n        }\n\n        if (params.path !== undefined) {\n            return Twig.Templates.loadRemote(params.path, {\n                id,\n                method: 'fs',\n                parser: params.parser || 'twig',\n                base: params.base,\n                module: params.module,\n                precompiled: params.precompiled,\n                async: params.async,\n                options\n            }, params.load, params.error);\n        }\n    };\n\n    // Extend Twig with a new filter.\n    Twig.exports.extendFilter = function (filter, definition) {\n        Twig.filter.extend(filter, definition);\n    };\n\n    // Extend Twig with a new function.\n    Twig.exports.extendFunction = function (fn, definition) {\n        Twig._function.extend(fn, definition);\n    };\n\n    // Extend Twig with a new test.\n    Twig.exports.extendTest = function (test, definition) {\n        Twig.test.extend(test, definition);\n    };\n\n    // Extend Twig with a new definition.\n    Twig.exports.extendTag = function (definition) {\n        Twig.logic.extend(definition);\n    };\n\n    // Provide an environment for extending Twig core.\n    // Calls fn with the internal Twig object.\n    Twig.exports.extend = function (fn) {\n        fn(Twig);\n    };\n\n    /**\n     * Provide an extension for use with express 2.\n     *\n     * @param {string} markup The template markup.\n     * @param {array} options The express options.\n     *\n     * @return {string} The rendered template.\n     */\n    Twig.exports.compile = function (markup, options) {\n        const id = options.filename;\n        const path = options.filename;\n\n        // Try to load the template from the cache\n        const template = new Twig.Template({\n            data: markup,\n            path,\n            id,\n            options: options.settings['twig options']\n        }); // Twig.Templates.load(id) ||\n\n        return function (context) {\n            return template.render(context);\n        };\n    };\n\n    /**\n     * Provide an extension for use with express 3.\n     *\n     * @param {string} path The location of the template file on disk.\n     * @param {Object|Function} The options or callback.\n     * @param {Function} fn callback.\n     *\n     * @throws Twig.Error\n     */\n    Twig.exports.renderFile = function (path, options, fn) {\n        // Handle callback in options\n        if (typeof options === 'function') {\n            fn = options;\n            options = {};\n        }\n\n        options = options || {};\n\n        const settings = options.settings || {};\n\n        // Mixin any options provided to the express app.\n        const viewOptions = settings['twig options'];\n\n        const params = {\n            path,\n            base: settings.views,\n            load(template) {\n                // Render and return template as a simple string, see https://github.com/twigjs/twig.js/pull/348 for more information\n                if (!viewOptions || !viewOptions.allowAsync) {\n                    fn(null, String(template.render(options)));\n                    return;\n                }\n\n                template.renderAsync(options)\n                    .then(out => fn(null, out), fn);\n            },\n            error(err) {\n                fn(err);\n            }\n        };\n\n        if (viewOptions) {\n            for (const option in viewOptions) {\n                if (Object.hasOwnProperty.call(viewOptions, option)) {\n                    params[option] = viewOptions[option];\n                }\n            }\n        }\n\n        Twig.exports.twig(params);\n    };\n\n    // Express 3 handler\n    Twig.exports.__express = Twig.exports.renderFile;\n\n    /**\n     * Shoud Twig.js cache templates.\n     * Disable during development to see changes to templates without\n     * reloading, and disable in production to improve performance.\n     *\n     * @param {boolean} cache\n     */\n    Twig.exports.cache = function (cache) {\n        Twig.cache = cache;\n    };\n\n    // We need to export the path module so we can effectively test it\n    Twig.exports.path = Twig.path;\n\n    // Export our filters.\n    // Resolves #307\n    Twig.exports.filters = Twig.filters;\n\n    // Export our tests.\n    Twig.exports.tests = Twig.tests;\n\n    // Export our functions.\n    Twig.exports.functions = Twig.functions;\n\n    Twig.exports.Promise = Twig.Promise;\n\n    return Twig;\n};\n"],"sourceRoot":""}