{"version":3,"file":"squirrelly.min.js","sources":["../../src/err.ts","../../src/utils.ts","../../src/parse.ts","../../src/compile-string.ts","../../src/storage.ts","../../src/container-utils.ts","../../src/containers.ts","../../src/config.ts","../../src/compile.ts","../../src/render.ts"],"sourcesContent":["function setPrototypeOf (obj: any, proto: any) {\n  if (Object.setPrototypeOf) {\n    Object.setPrototypeOf(obj, proto)\n  } else {\n    obj.__proto__ = proto\n  }\n}\n\nexport default function SqrlErr (message: string): Error {\n  var err = new Error(message)\n  setPrototypeOf(err, SqrlErr.prototype)\n  return err\n}\n\nSqrlErr.prototype = Object.create(Error.prototype, {\n  name: { value: 'Squirrelly Error', enumerable: false }\n})\n\n// TODO: Class transpilation adds a lot to the bundle size\n\nexport function ParseErr (message: string, str: string, indx: number) {\n  var whitespace = str.slice(0, indx).split(/\\n/)\n\n  var lineNo = whitespace.length\n  var colNo = whitespace[lineNo - 1].length + 1\n  message +=\n    ' at line ' +\n    lineNo +\n    ' col ' +\n    colNo +\n    ':\\n\\n' +\n    '  ' +\n    str.split(/\\n/)[lineNo - 1] +\n    '\\n' +\n    '  ' +\n    Array(colNo).join(' ') +\n    '^'\n  throw SqrlErr(message)\n}\n","// TODO: allow '-' to trim up until newline. Use [^\\S\\n\\r] instead of \\s\n// TODO: only include trimLeft polyfill if not in ES6\n\n/* TYPES */\n\nimport { SqrlConfig } from './config'\n\n/* END TYPES */\n\nexport var promiseImpl = new Function('return this')().Promise\n\nvar asyncFunc: FunctionConstructor | false = false\n\ntry {\n  asyncFunc = new Function('return (async function(){}).constructor')()\n} catch (e) {\n  // We shouldn't actually ever have any other errors, but...\n  if (!(e instanceof SyntaxError)) {\n    throw e\n  }\n}\n\nexport { asyncFunc }\n\nexport function hasOwnProp (obj: object, prop: string) {\n  return Object.prototype.hasOwnProperty.call(obj, prop)\n}\n\nexport function copyProps<T> (toObj: T, fromObj: T, notConfig?: boolean) {\n  for (var key in fromObj) {\n    if (hasOwnProp((fromObj as unknown) as object, key)) {\n      if (\n        fromObj[key] != null &&\n        typeof fromObj[key] == 'object' &&\n        (key === 'storage' || key === 'prefixes') &&\n        !notConfig // not called from Cache.load\n      ) {\n        // plugins or storage\n        // Note: this doesn't merge from initial config!\n        // Deep clone instead of assigning\n        // TODO: run checks on this\n        toObj[key] = copyProps(/*toObj[key] ||*/ {} as T[Extract<keyof T, string>], fromObj[key])\n      } else {\n        toObj[key] = fromObj[key]\n      }\n    }\n  }\n  return toObj\n}\n\nfunction trimWS (\n  str: string,\n  env: SqrlConfig,\n  wsLeft: string | false,\n  wsRight?: string | false\n): string {\n  var leftTrim\n  var rightTrim\n\n  if (typeof env.autoTrim === 'string') {\n    leftTrim = rightTrim = env.autoTrim\n    // Don't need to check if env.autoTrim is false\n    // Because leftTrim, rightTrim are initialized as falsy\n  } else if (Array.isArray(env.autoTrim)) {\n    // kinda confusing\n    // but _}} will trim the left side of the following string\n    leftTrim = env.autoTrim[1]\n    rightTrim = env.autoTrim[0]\n  }\n\n  if (wsLeft || wsLeft === false) {\n    leftTrim = wsLeft\n  }\n\n  if (wsRight || wsRight === false) {\n    rightTrim = wsRight\n  }\n\n  if (leftTrim === 'slurp' && rightTrim === 'slurp') {\n    return str.trim()\n  }\n\n  if (leftTrim === '_' || leftTrim === 'slurp') {\n    // console.log('trimming left' + leftTrim)\n    // full slurp\n    // eslint-disable-next-line no-extra-boolean-cast\n    if (!!String.prototype.trimLeft) {\n      str = str.trimLeft()\n    } else {\n      str = str.replace(/^[\\s\\uFEFF\\xA0]+/, '')\n    }\n  } else if (leftTrim === '-' || leftTrim === 'nl') {\n    // console.log('trimming left nl' + leftTrim)\n    // nl trim\n    str = str.replace(/^(?:\\n|\\r|\\r\\n)/, '')\n  }\n\n  if (rightTrim === '_' || rightTrim === 'slurp') {\n    // console.log('trimming right' + rightTrim)\n    // full slurp\n    // eslint-disable-next-line no-extra-boolean-cast\n    if (!!String.prototype.trimRight) {\n      str = str.trimRight()\n    } else {\n      str = str.replace(/[\\s\\uFEFF\\xA0]+$/, '')\n    }\n  } else if (rightTrim === '-' || rightTrim === 'nl') {\n    // console.log('trimming right nl' + rightTrim)\n    // nl trim\n    str = str.replace(/(?:\\n|\\r|\\r\\n)$/, '') // TODO: make sure this gets \\r\\n\n  }\n\n  return str\n}\n\nexport { trimWS }\n","import SqrlErr, { ParseErr } from './err'\nimport { trimWS } from './utils'\n\n/* TYPES */\n\nimport { SqrlConfig } from './config'\n\nexport type TagType = 'h' | 'b' | 'i' | 'r' | 'c' | 'e' | 'q' | 's'\n// TODO: change to anagram \"QBIRCHES\"\nexport type TemplateAttribute = 'c' | 'f' | 'fp' | 'p' | 'n' | 'res' | 'err'\nexport type TemplateObjectAttribute = 'c' | 'p' | 'n' | 'res'\n\nexport type AstObject = string | TemplateObject\n\nexport type Filter = [string, string] | [string, string, true]\n// [name, params, async]\nexport interface TemplateObject {\n  n?: string\n  t?: 'h' | 'b' | 'i' | 'c' | 'q' | 'e' | 's'\n  f: Array<Filter>\n  c?: string\n  p?: string\n  res?: string\n  d?: Array<AstObject>\n  raw?: boolean\n  a?: boolean // async\n  b?: Array<ParentTemplateObject>\n}\n\nexport interface ParentTemplateObject extends TemplateObject {\n  d: Array<AstObject>\n  b: Array<ParentTemplateObject>\n}\n\n/* END TYPES */\n\nvar asyncRegExp = /^async +/\n\nvar templateLitReg = /`(?:\\\\[\\s\\S]|\\${(?:[^{}]|{(?:[^{}]|{[^}]*})*})*}|(?!\\${)[^\\\\`])*`/g\n\nvar singleQuoteReg = /'(?:\\\\[\\s\\w\"'\\\\`]|[^\\n\\r'\\\\])*?'/g\n\nvar doubleQuoteReg = /\"(?:\\\\[\\s\\w\"'\\\\`]|[^\\n\\r\"\\\\])*?\"/g\n\nvar specialCharsReg = /[.*+\\-?^${}()|[\\]\\\\]/g\n\nfunction escapeRegExp (string: string) {\n  // From MDN\n  return specialCharsReg.test(string)\n    ? string.replace(specialCharsReg, '\\\\$&') // $& means the whole matched string\n    : string\n}\n\nexport default function parse (str: string, env: SqrlConfig): Array<AstObject> {\n  /* Adding for EJS compatibility */\n  if (env.rmWhitespace) {\n    // Code taken directly from EJS\n    // Have to use two separate replaces here as `^` and `$` operators don't\n    // work well with `\\r` and empty lines don't work well with the `m` flag.\n    // Essentially, this replaces the whitespace at the beginning and end of\n    // each line and removes multiple newlines.\n    str = str.replace(/[\\r\\n]+/g, '\\n').replace(/^\\s+|\\s+$/gm, '')\n  }\n  /* End rmWhitespace option */\n\n  templateLitReg.lastIndex = 0\n  singleQuoteReg.lastIndex = 0\n  doubleQuoteReg.lastIndex = 0\n\n  var envPrefixes = env.prefixes\n\n  var prefixes = [\n    envPrefixes.h,\n    envPrefixes.b,\n    envPrefixes.i,\n    envPrefixes.r,\n    envPrefixes.c,\n    envPrefixes.e\n  ].reduce(function (accumulator, prefix) {\n    if (accumulator && prefix) {\n      return accumulator + '|' + escapeRegExp(prefix)\n    } else if (prefix) {\n      // accumulator is empty\n      return escapeRegExp(prefix)\n    } else {\n      // prefix and accumulator are both empty strings\n      return accumulator\n    }\n  }, '')\n\n  var parseCloseReg = new RegExp(\n    '([|()]|=>)|' + // powerchars\n    '(\\'|\"|`|\\\\/\\\\*)|\\\\s*((\\\\/)?(-|_)?' + // comments, strings\n      escapeRegExp(env.tags[1]) +\n      ')',\n    'g'\n  )\n\n  var tagOpenReg = new RegExp(\n    '([^]*?)' + escapeRegExp(env.tags[0]) + '(-|_)?\\\\s*(' + prefixes + ')?\\\\s*',\n    'g'\n  )\n\n  var startInd = 0\n  var trimNextLeftWs: string | false = false\n\n  function parseTag (tagOpenIndex: number, currentType: TagType): TemplateObject {\n    var currentObj: TemplateObject = { f: [] }\n    var numParens = 0\n    var currentAttribute: TemplateAttribute = 'c' // default - Valid values: 'c'=content, 'f'=filter, 'fp'=filter params, 'p'=param, 'n'=name\n\n    if (currentType === 'h' || currentType === 'b' || currentType === 'c') {\n      currentAttribute = 'n'\n    } else if (currentType === 'r') {\n      currentObj.raw = true\n      currentType = 'i'\n    }\n\n    function addAttrValue (indx: number) {\n      var valUnprocessed = str.slice(startInd, indx)\n      // console.log(valUnprocessed)\n      var val = valUnprocessed.trim()\n      if (currentAttribute === 'f') {\n        if (val === 'safe') {\n          currentObj.raw = true\n        } else {\n          if (env.async && asyncRegExp.test(val)) {\n            val = val.replace(asyncRegExp, '')\n            currentObj.f.push([val, '', true])\n          } else {\n            currentObj.f.push([val, ''])\n          }\n        }\n      } else if (currentAttribute === 'fp') {\n        currentObj.f[currentObj.f.length - 1][1] += val\n      } else if (currentAttribute === 'err') {\n        if (val) {\n          var found = valUnprocessed.search(/\\S/)\n          ParseErr('invalid syntax', str, startInd + found)\n        }\n      } else {\n        // if (currentObj[currentAttribute]) { // TODO make sure no errs\n        //   currentObj[currentAttribute] += val\n        // } else {\n        currentObj[currentAttribute] = val\n        // }\n      }\n      startInd = indx + 1\n    }\n\n    parseCloseReg.lastIndex = startInd\n\n    var m\n    // tslint:disable-next-line:no-conditional-assignment\n    while ((m = parseCloseReg.exec(str)) !== null) {\n      var char = m[1]\n      var punctuator = m[2]\n      var tagClose = m[3]\n      var slash = m[4]\n      var wsControl = m[5]\n      var i = m.index\n\n      if (char) {\n        // Power character\n        if (char === '(') {\n          if (numParens === 0) {\n            if (currentAttribute === 'n') {\n              addAttrValue(i)\n              currentAttribute = 'p'\n            } else if (currentAttribute === 'f') {\n              addAttrValue(i)\n              currentAttribute = 'fp'\n            }\n          }\n          numParens++\n        } else if (char === ')') {\n          numParens--\n          if (numParens === 0 && currentAttribute !== 'c') {\n            // Then it's closing a filter, block, or helper\n            addAttrValue(i)\n\n            currentAttribute = 'err' // Reset the current attribute\n          }\n        } else if (numParens === 0 && char === '|') {\n          addAttrValue(i) // this should actually always be whitespace or empty\n          currentAttribute = 'f'\n        } else if (char === '=>') {\n          addAttrValue(i)\n          startInd += 1 // this is 2 chars\n          currentAttribute = 'res'\n        }\n      } else if (punctuator) {\n        if (punctuator === '/*') {\n          var commentCloseInd = str.indexOf('*/', parseCloseReg.lastIndex)\n          if (commentCloseInd === -1) {\n            ParseErr('unclosed comment', str, m.index)\n          }\n          parseCloseReg.lastIndex = commentCloseInd + 2 // since */ is 2 characters, and we're using indexOf rather than a RegExp\n        } else if (punctuator === \"'\") {\n          singleQuoteReg.lastIndex = m.index\n\n          var singleQuoteMatch = singleQuoteReg.exec(str)\n          if (singleQuoteMatch) {\n            parseCloseReg.lastIndex = singleQuoteReg.lastIndex\n          } else {\n            ParseErr('unclosed string', str, m.index)\n          }\n        } else if (punctuator === '\"') {\n          doubleQuoteReg.lastIndex = m.index\n          var doubleQuoteMatch = doubleQuoteReg.exec(str)\n\n          if (doubleQuoteMatch) {\n            parseCloseReg.lastIndex = doubleQuoteReg.lastIndex\n          } else {\n            ParseErr('unclosed string', str, m.index)\n          }\n        } else if (punctuator === '`') {\n          templateLitReg.lastIndex = m.index\n          var templateLitMatch = templateLitReg.exec(str)\n          if (templateLitMatch) {\n            parseCloseReg.lastIndex = templateLitReg.lastIndex\n          } else {\n            ParseErr('unclosed string', str, m.index)\n          }\n        }\n      } else if (tagClose) {\n        addAttrValue(i)\n        startInd = i + m[0].length\n        tagOpenReg.lastIndex = startInd\n        // console.log('tagClose: ' + startInd)\n        trimNextLeftWs = wsControl\n        if (slash && currentType === 'h') {\n          currentType = 's'\n        } // TODO throw err\n        currentObj.t = currentType\n        return currentObj\n      }\n    }\n    ParseErr('unclosed tag', str, tagOpenIndex)\n    return currentObj // To prevent TypeScript from erroring\n  }\n\n  function parseContext (parentObj: TemplateObject, firstParse?: boolean): ParentTemplateObject {\n    parentObj.b = [] // assume there will be blocks // TODO: perf optimize this\n    parentObj.d = []\n    var lastBlock: ParentTemplateObject | false = false\n    var buffer: Array<AstObject> = []\n\n    function pushString (strng: string, shouldTrimRightOfString?: string | false) {\n      if (strng) {\n        // if string is truthy it must be of type 'string'\n\n        // TODO: benchmark replace( /(\\\\|')/g, '\\\\$1')\n        strng = trimWS(\n          strng,\n          env,\n          trimNextLeftWs, // this will only be false on the first str, the next ones will be null or undefined\n          shouldTrimRightOfString\n        )\n\n        if (strng) {\n          // replace \\ with \\\\, ' with \\'\n\n          strng = strng.replace(/\\\\|'/g, '\\\\$&').replace(/\\r\\n|\\n|\\r/g, '\\\\n')\n          // we're going to convert all CRLF to LF so it doesn't take more than one replace\n\n          buffer.push(strng)\n        }\n      }\n    }\n\n    // Random TODO: parentObj.b doesn't need to have t: #\n    var tagOpenMatch\n    // tslint:disable-next-line:no-conditional-assignment\n    while ((tagOpenMatch = tagOpenReg.exec(str)) !== null) {\n      var precedingString = tagOpenMatch[1]\n      var shouldTrimRightPrecedingString = tagOpenMatch[2]\n      var prefix = tagOpenMatch[3] || ''\n      var prefixType: TagType | undefined\n\n      for (var key in envPrefixes) {\n        if (envPrefixes[key] === prefix) {\n          prefixType = key as TagType\n          break\n        }\n      }\n\n      pushString(precedingString, shouldTrimRightPrecedingString)\n      startInd = tagOpenMatch.index + tagOpenMatch[0].length\n\n      if (!prefixType) {\n        ParseErr('unrecognized tag type: ' + prefix, str, startInd)\n      }\n\n      var currentObj = parseTag(tagOpenMatch.index, prefixType as TagType)\n      // ===== NOW ADD THE OBJECT TO OUR BUFFER =====\n\n      var currentType = currentObj.t\n      if (currentType === 'h') {\n        var hName = currentObj.n || ''\n        if (env.async && asyncRegExp.test(hName)) {\n          currentObj.a = true\n          currentObj.n = hName.replace(asyncRegExp, '')\n        }\n        currentObj = parseContext(currentObj) // currentObj is the parent object\n        buffer.push(currentObj)\n      } else if (currentType === 'c') {\n        // tag close\n        if (parentObj.n === currentObj.n) {\n          if (lastBlock) {\n            // If there's a previous block\n            lastBlock.d = buffer\n            parentObj.b.push(lastBlock)\n          } else {\n            parentObj.d = buffer\n          }\n          // console.log('parentObj: ' + JSON.stringify(parentObj))\n          return parentObj as ParentTemplateObject\n        } else {\n          ParseErr(\n            \"Helper start and end don't match\",\n            str,\n            tagOpenMatch.index + tagOpenMatch[0].length\n          )\n        }\n      } else if (currentType === 'b') {\n        // block\n        // TODO: make sure async stuff inside blocks are recognized\n        if (lastBlock) {\n          // If there's a previous block\n          lastBlock.d = buffer\n          parentObj.b.push(lastBlock)\n        } else {\n          parentObj.d = buffer\n        }\n\n        var blockName = currentObj.n || ''\n        if (env.async && asyncRegExp.test(blockName)) {\n          currentObj.a = true\n          currentObj.n = blockName.replace(asyncRegExp, '')\n        }\n\n        lastBlock = currentObj as ParentTemplateObject // Set the 'lastBlock' object to the value of the current block\n\n        buffer = []\n      } else if (currentType === 's') {\n        var selfClosingHName = currentObj.n || ''\n        if (env.async && asyncRegExp.test(selfClosingHName)) {\n          currentObj.a = true\n          currentObj.n = selfClosingHName.replace(asyncRegExp, '')\n        }\n        buffer.push(currentObj)\n      } else {\n        buffer.push(currentObj)\n      }\n      // ===== DONE ADDING OBJECT TO BUFFER =====\n    }\n\n    if (firstParse) {\n      pushString(str.slice(startInd, str.length), false)\n      parentObj.d = buffer\n    } else {\n      throw SqrlErr('unclosed helper \"' + parentObj.n + '\"')\n      // It should have returned by now\n    }\n\n    return parentObj as ParentTemplateObject\n  }\n\n  var parseResult = parseContext({ f: [] }, true)\n  // console.log(JSON.stringify(parseResult))\n  if (env.plugins) {\n    for (var i = 0; i < env.plugins.length; i++) {\n      var plugin = env.plugins[i]\n      if (plugin.processAST) {\n        parseResult.d = plugin.processAST(parseResult.d, env)\n      }\n    }\n  }\n  return parseResult.d // Parse the very outside context\n}\n","import Parse from './parse'\n\n/* TYPES */\n\nimport { SqrlConfig } from './config'\nimport { AstObject, Filter, ParentTemplateObject } from './parse'\ntype ParsedTagType = 'h' | 's' | 'e' | 'i'\n// import SqrlErr from './err'\n\n/* END TYPES */\n\nexport default function compileToString (str: string, env: SqrlConfig) {\n  var buffer: Array<AstObject> = Parse(str, env)\n\n  var res =\n    \"var tR='';\" +\n    (env.useWith ? 'with(' + env.varName + '||{}){' : '') +\n    compileScope(buffer, env) +\n    'if(cb){cb(null,tR)} return tR' +\n    (env.useWith ? '}' : '')\n\n  if (env.plugins) {\n    for (var i = 0; i < env.plugins.length; i++) {\n      var plugin = env.plugins[i]\n      if (plugin.processFnString) {\n        res = plugin.processFnString(res, env)\n      }\n    }\n  }\n\n  return res\n\n  // TODO: is `return cb()` necessary, or could we just do `cb()`\n}\n\nfunction filter (str: string, filters: Array<Filter>) {\n  for (var i = 0; i < filters.length; i++) {\n    var name = filters[i][0]\n    var params = filters[i][1]\n    var isFilterAsync = filters[i][2]\n\n    // if (isFilterAsync && !env.async) {\n    //   throw SqrlErr(\"Async filter '\" + name + \"' in non-async env\")\n    // }\n    // Let the JS compiler do this, compile() will catch it\n\n    str = (isFilterAsync ? 'await ' : '') + \"c.l('F','\" + name + \"')(\" + str\n    if (params) {\n      str += ',' + params\n    }\n    str += ')'\n  }\n  return str\n}\n\n// TODO: Use type intersections for TemplateObject, etc.\n// so I don't have to make properties mandatory\n\nfunction compileHelper (\n  env: SqrlConfig,\n  res: string,\n  descendants: Array<AstObject>,\n  params: string,\n  isAsync?: boolean,\n  name?: string\n) {\n  var ret =\n    '{exec:' +\n    (isAsync ? 'async ' : '') +\n    compileScopeIntoFunction(descendants, res, env) +\n    ',params:[' +\n    params +\n    ']'\n  if (name) {\n    ret += \",name:'\" + name + \"'\"\n  }\n  if (isAsync) {\n    ret += ',async:true'\n  }\n  ret += '}'\n  return ret\n}\n\nfunction compileBlocks (blocks: Array<ParentTemplateObject>, env: SqrlConfig) {\n  var ret = '['\n  for (var i = 0; i < blocks.length; i++) {\n    var block = blocks[i]\n    ret += compileHelper(env, block.res || '', block.d, block.p || '', block.a, block.n)\n    if (i < blocks.length) {\n      ret += ','\n    }\n  }\n  ret += ']'\n  return ret\n}\n\nexport function compileScopeIntoFunction (buff: Array<AstObject>, res: string, env: SqrlConfig) {\n  return 'function(' + res + \"){var tR='';\" + compileScope(buff, env) + 'return tR}'\n}\n\nexport function compileScope (buff: Array<AstObject>, env: SqrlConfig) {\n  var i = 0\n  var buffLength = buff.length\n  var returnStr = ''\n\n  for (i; i < buffLength; i++) {\n    var currentBlock = buff[i]\n    if (typeof currentBlock === 'string') {\n      var str = currentBlock\n\n      // we know string exists\n      returnStr += \"tR+='\" + str + \"';\"\n    } else {\n      var type: ParsedTagType = currentBlock.t as ParsedTagType // h, s, e, i\n      var content = currentBlock.c || ''\n      var filters = currentBlock.f\n      var name = currentBlock.n || ''\n      var params = currentBlock.p || ''\n      var res = currentBlock.res || ''\n      var blocks = currentBlock.b\n      var isAsync = !!currentBlock.a // !! is to booleanize it\n      // if (isAsync && !env.async) {\n      //   throw SqrlErr(\"Async block or helper '\" + name + \"' in non-async env\")\n      // }\n      // Let compiler do this\n      if (type === 'i') {\n        if (env.defaultFilter) {\n          content = \"c.l('F','\" + env.defaultFilter + \"')(\" + content + ')'\n        }\n        var filtered = filter(content, filters)\n        if (!currentBlock.raw && env.autoEscape) {\n          filtered = \"c.l('F','e')(\" + filtered + ')'\n        }\n        returnStr += 'tR+=' + filtered + ';'\n        // reference\n      } else if (type === 'h') {\n        // helper\n        if (env.storage.nativeHelpers.get(name)) {\n          returnStr += env.storage.nativeHelpers.get(name)(currentBlock, env)\n        } else {\n          var helperReturn =\n            (isAsync ? 'await ' : '') +\n            \"c.l('H','\" +\n            name +\n            \"')(\" +\n            compileHelper(env, res, (currentBlock as ParentTemplateObject).d, params, isAsync)\n          if (blocks) {\n            helperReturn += ',' + compileBlocks(blocks, env)\n          } else {\n            helperReturn += ',[]'\n          }\n          helperReturn += ',c)'\n\n          returnStr += 'tR+=' + filter(helperReturn, filters) + ';'\n        }\n      } else if (type === 's') {\n        // self-closing helper\n\n        returnStr +=\n          'tR+=' +\n          filter(\n            (isAsync ? 'await ' : '') + \"c.l('H','\" + name + \"')({params:[\" + params + ']},[],c)',\n            filters\n          ) +\n          ';'\n      } else if (type === 'e') {\n        // execute\n        returnStr += content + '\\n'\n      }\n    }\n  }\n\n  return returnStr\n}\n","import { copyProps } from './utils'\n\n/* TYPES */\n\ninterface Dict<T> {\n  // Basically, an object where all keys point to a value of the same type\n  [key: string]: T\n}\n\n/* END TYPES */\n\nclass Cacher<T> {\n  constructor (private cache: Dict<T>) {}\n  define (key: string, val: T) {\n    this.cache[key] = val\n  }\n  get (key: string) {\n    // string | array.\n    // TODO: allow array of keys to look down\n    // TODO: create plugin to allow referencing helpers, filters with dot notation\n    return this.cache[key]\n  }\n  remove (key: string) {\n    delete this.cache[key]\n  }\n  reset () {\n    this.cache = {}\n  }\n  load (cacheObj: Dict<T>) {\n    // TODO: this will err with deep objects and `storage` or `plugins` keys.\n    // Update Feb 26: EDITED so it shouldn't err\n    copyProps(this.cache, cacheObj, true)\n  }\n}\n\nexport { Cacher }\n","import SqrlErr from './err'\n\nexport function errWithBlocksOrFilters(\n  name: string,\n  blocks: Array<any> | false, // false means don't check\n  filters: Array<any> | false,\n  native?: boolean\n) {\n  if (blocks && blocks.length > 0) {\n    throw SqrlErr((native ? 'Native' : '') + \"Helper '\" + name + \"' doesn't accept blocks\")\n  }\n  if (filters && filters.length > 0) {\n    throw SqrlErr((native ? 'Native' : '') + \"Helper '\" + name + \"' doesn't accept filters\")\n  }\n}\n\n/* ASYNC LOOP FNs */\nexport function asyncArrLoop(\n  arr: Array<any>,\n  index: number,\n  fn: Function,\n  res: string,\n  cb: Function\n) {\n  fn(arr[index], index).then(function (val: string) {\n    res += val\n    if (index === arr.length - 1) {\n      cb(res)\n    } else {\n      asyncArrLoop(arr, index + 1, fn, res, cb)\n    }\n  })\n}\n\nexport function asyncObjLoop(\n  obj: { [index: string]: any },\n  keys: Array<string>,\n  index: number,\n  fn: Function,\n  res: string,\n  cb: Function\n) {\n  fn(keys[index], obj[keys[index]]).then(function (val: string) {\n    res += val\n    if (index === keys.length - 1) {\n      cb(res)\n    } else {\n      asyncObjLoop(obj, keys, index + 1, fn, res, cb)\n    }\n  })\n}\n\nvar escMap: EscapeMap = {\n  '&': '&amp;',\n  '<': '&lt;',\n  '>': '&gt;',\n  '\"': '&quot;',\n  \"'\": '&#39;',\n}\n\nexport function replaceChar(s: string): string {\n  return escMap[s]\n}\n\nexport function XMLEscape(str: unknown) {\n  // To deal with XSS. Based on Escape implementations of Mustache.JS and Marko, then customized.\n  var newStr = String(str)\n  if (/[&<>\"']/.test(newStr)) {\n    return newStr.replace(/[&<>\"']/g, replaceChar)\n  } else {\n    return newStr\n  }\n}\n\n/* INTERFACES */\ninterface EscapeMap {\n  '&': '&amp;'\n  '<': '&lt;'\n  '>': '&gt;'\n  '\"': '&quot;'\n  \"'\": '&#39;'\n  [index: string]: string\n}\n","import { Cacher } from './storage'\nimport SqrlErr from './err'\nimport { compileScope, compileScopeIntoFunction } from './compile-string'\nimport { hasOwnProp } from './utils'\nimport { errWithBlocksOrFilters, asyncArrLoop, asyncObjLoop, XMLEscape } from './container-utils'\n\n/* TYPES */\n\nimport { SqrlConfig } from './config'\nimport { TemplateFunction } from './compile'\nimport { ParentTemplateObject } from './parse'\n\nexport interface HelperContent {\n  exec: Function\n  params: Array<any>\n  async?: boolean\n}\n\nexport interface HelperBlock extends HelperContent {\n  name: string\n}\n\nexport type HelperFunction = (\n  content: HelperContent,\n  blocks: Array<HelperBlock>,\n  config: SqrlConfig\n) => string | Promise<string>\n\nexport type FilterFunction = (...args: any[]) => any | Promise<any>\n\ninterface IncludeHelperContent extends HelperContent {\n  params: [string, object]\n}\n\ninterface GenericData {\n  [index: string]: any\n}\n\n/* END TYPES */\n\nvar templates = new Cacher<TemplateFunction>({})\n\n/* ASYNC LOOP FNs */\n\nvar helpers = new Cacher<HelperFunction>({\n  each: function (content: HelperContent, blocks: Array<HelperBlock>) {\n    var res = ''\n    var arr = content.params[0]\n    errWithBlocksOrFilters('each', blocks, false)\n\n    if (content.async) {\n      return new Promise(function (resolve) {\n        asyncArrLoop(arr, 0, content.exec, res, resolve)\n      })\n    } else {\n      for (var i = 0; i < arr.length; i++) {\n        res += content.exec(arr[i], i)\n      }\n      return res\n    }\n  },\n  foreach: function (content: HelperContent, blocks: Array<HelperBlock>) {\n    var obj = content.params[0]\n    errWithBlocksOrFilters('foreach', blocks, false)\n\n    if (content.async) {\n      return new Promise(function (resolve) {\n        asyncObjLoop(obj, Object.keys(obj), 0, content.exec, '', resolve)\n      })\n    } else {\n      var res = ''\n\n      for (var key in obj) {\n        if (!hasOwnProp(obj, key)) continue\n        res += content.exec(key, obj[key]) // todo: check on order\n      }\n      return res\n    }\n  },\n  include: function (\n    content: IncludeHelperContent,\n    blocks: Array<HelperBlock>,\n    config: SqrlConfig\n  ): string {\n    errWithBlocksOrFilters('include', blocks, false)\n    var template = config.storage.templates.get(content.params[0])\n    if (!template) {\n      throw SqrlErr('Could not fetch template \"' + content.params[0] + '\"')\n    }\n    return template(content.params[1], config)\n  } as HelperFunction,\n  extends: function (\n    content: IncludeHelperContent,\n    blocks: Array<HelperBlock>,\n    config: SqrlConfig\n  ): string {\n    var data: GenericData = content.params[1] || {}\n    data.content = content.exec()\n\n    for (var i = 0; i < blocks.length; i++) {\n      var currentBlock = blocks[i]\n      data[currentBlock.name] = currentBlock.exec()\n    }\n\n    var template = config.storage.templates.get(content.params[0])\n    if (!template) {\n      throw SqrlErr('Could not fetch template \"' + content.params[0] + '\"')\n    }\n    return template(data, config)\n  } as HelperFunction,\n  useScope: function (content: HelperContent, blocks: Array<HelperBlock>): string {\n    errWithBlocksOrFilters('useScope', blocks, false)\n\n    return content.exec(content.params[0])\n  } as HelperFunction\n})\n\nvar nativeHelpers = new Cacher<Function>({\n  if: function (buffer: ParentTemplateObject, env: SqrlConfig) {\n    errWithBlocksOrFilters('if', false, buffer.f, true)\n\n    var returnStr = 'if(' + buffer.p + '){' + compileScope(buffer.d, env) + '}'\n    if (buffer.b) {\n      for (var i = 0; i < buffer.b.length; i++) {\n        var currentBlock = buffer.b[i]\n        if (currentBlock.n === 'else') {\n          returnStr += 'else{' + compileScope(currentBlock.d, env) + '}'\n        } else if (currentBlock.n === 'elif') {\n          returnStr += 'else if(' + currentBlock.p + '){' + compileScope(currentBlock.d, env) + '}'\n        }\n      }\n    }\n    return returnStr\n  },\n  try: function (buffer: ParentTemplateObject, env: SqrlConfig) {\n    errWithBlocksOrFilters('try', false, buffer.f, true)\n\n    if (!buffer.b || buffer.b.length !== 1 || buffer.b[0].n !== 'catch') {\n      throw SqrlErr(\"native helper 'try' only accepts 1 block, 'catch'\")\n    }\n    var returnStr = 'try{' + compileScope(buffer.d, env) + '}'\n\n    var currentBlock = buffer.b[0]\n    returnStr +=\n      'catch' +\n      (currentBlock.res ? '(' + currentBlock.res + ')' : '') +\n      '{' +\n      compileScope(currentBlock.d, env) +\n      '}'\n\n    return returnStr\n  },\n  block: function (buffer: ParentTemplateObject, env: SqrlConfig) {\n    errWithBlocksOrFilters('block', buffer.b, buffer.f, true)\n\n    var returnStr =\n      'if(!' +\n      env.varName +\n      '[' +\n      buffer.p +\n      ']){tR+=(' +\n      compileScopeIntoFunction(buffer.d, '', env) +\n      ')()}else{tR+=' +\n      env.varName +\n      '[' +\n      buffer.p +\n      ']}'\n\n    return returnStr\n  }\n})\n\nvar filters = new Cacher<FilterFunction>({ e: XMLEscape })\n\nexport { templates, helpers, nativeHelpers, filters }\n","import { helpers, nativeHelpers, filters, templates } from './containers'\nimport SqrlErr from './err'\nimport { copyProps } from './utils'\n\n/* TYPES */\n\nexport type FetcherFunction = (container: 'H' | 'F', name: string) => Function | undefined\nimport { HelperFunction, FilterFunction } from './containers'\nimport { TemplateFunction } from './compile'\nimport { Cacher } from './storage'\n// import { TagType } from './parse'\n\ntype trimConfig = 'nl' | 'slurp' | false\n\nexport interface SqrlConfig {\n  varName: string\n  autoTrim: trimConfig | [trimConfig, trimConfig]\n  rmWhitespace?: boolean\n  autoEscape: boolean\n  defaultFilter: false | string\n  tags: [string, string]\n  l: FetcherFunction\n  plugins: Array<{ processFnString?: Function; processAST?: Function }>\n  async: boolean\n  storage: {\n    helpers: Cacher<HelperFunction>\n    nativeHelpers: Cacher<Function>\n    filters: Cacher<FilterFunction>\n    templates: Cacher<TemplateFunction>\n  }\n  prefixes: {\n    h: string\n    b: string\n    i: string\n    r: string\n    c: string\n    e: string\n    [index: string]: string\n  }\n  cache: boolean\n  views?: string | Array<string>\n  root?: string\n  filename?: string\n  name?: string\n  'view cache'?: boolean\n  useWith?: boolean\n  [index: string]: any\n}\n\nexport type PartialConfig = {\n  [P in keyof SqrlConfig]?: SqrlConfig[P]\n}\n\n/* END TYPES */\n\nvar defaultConfig: SqrlConfig = {\n  varName: 'it',\n  autoTrim: [false, 'nl'],\n  autoEscape: true,\n  defaultFilter: false,\n  tags: ['{{', '}}'],\n  l: function (container: 'H' | 'F', name: string): HelperFunction | FilterFunction | undefined {\n    if (container === 'H') {\n      var hRet = this.storage.helpers.get(name) as HelperFunction | undefined\n      if (hRet) {\n        return hRet\n      } else {\n        throw SqrlErr(\"Can't find helper '\" + name + \"'\")\n      }\n    } else if (container === 'F') {\n      var fRet = this.storage.filters.get(name) as FilterFunction | undefined\n      if (fRet) {\n        return fRet\n      } else {\n        throw SqrlErr(\"Can't find filter '\" + name + \"'\")\n      }\n    }\n  },\n  async: false,\n  storage: {\n    helpers: helpers,\n    nativeHelpers: nativeHelpers,\n    filters: filters,\n    templates: templates\n  },\n  prefixes: {\n    h: '@',\n    b: '#',\n    i: '',\n    r: '*',\n    c: '/',\n    e: '!'\n  },\n  cache: false,\n  plugins: [],\n  useWith: false\n}\n\ndefaultConfig.l.bind(defaultConfig)\n\nfunction getConfig (override: PartialConfig, baseConfig?: SqrlConfig): SqrlConfig {\n  // TODO: run more tests on this\n\n  var res: PartialConfig = {} // Linked\n  copyProps(res, defaultConfig) // Creates deep clone of res, 1 layer deep\n\n  if (baseConfig) {\n    copyProps(res, baseConfig)\n  }\n\n  if (override) {\n    copyProps(res, override)\n  }\n\n  ;(res as SqrlConfig).l.bind(res)\n\n  return res as SqrlConfig\n}\n\nexport { defaultConfig, getConfig }\n","import compileToString from './compile-string'\nimport { getConfig } from './config'\nimport { asyncFunc } from './utils'\nimport SqrlErr from './err'\n\n/* TYPES */\n\nimport { SqrlConfig, PartialConfig } from './config'\nimport { CallbackFn } from './file-handlers'\nexport type TemplateFunction = (data: object, config: SqrlConfig, cb?: CallbackFn) => string\n\n/* END TYPES */\n\nexport default function compile (str: string, env?: PartialConfig): TemplateFunction {\n  var options: SqrlConfig = getConfig(env || {})\n  var ctor = Function // constructor\n\n  /* ASYNC HANDLING */\n  // The below code is modified from mde/ejs. All credit should go to them.\n  if (options.async) {\n    // Have to use generated function for this, since in envs without support,\n    // it breaks in parsing\n    if (asyncFunc) {\n      ctor = asyncFunc\n    } else {\n      throw SqrlErr(\"This environment doesn't support async/await\")\n    }\n  }\n\n  /* END ASYNC HANDLING */\n  try {\n    return new ctor(\n      options.varName,\n      'c', // SqrlConfig\n      'cb', // optional callback\n      compileToString(str, options)\n    ) as TemplateFunction // eslint-disable-line no-new-func\n  } catch (e) {\n    if (e instanceof SyntaxError) {\n      throw SqrlErr(\n        'Bad template syntax\\n\\n' +\n          e.message +\n          '\\n' +\n          Array(e.message.length + 1).join('=') +\n          '\\n' +\n          compileToString(str, options)\n      )\n    } else {\n      throw e\n    }\n  }\n}\n","import compile from './compile'\nimport { getConfig } from './config'\nimport { promiseImpl } from './utils'\nimport SqrlErr from './err'\n\n/* TYPES */\n\nimport { SqrlConfig, PartialConfig } from './config'\nimport { TemplateFunction } from './compile'\nimport { CallbackFn } from './file-handlers'\n\n/* END TYPES */\n\nfunction handleCache (template: string | TemplateFunction, options: SqrlConfig): TemplateFunction {\n  var templateFunc\n\n  if (options.cache && options.name && options.storage.templates.get(options.name)) {\n    return options.storage.templates.get(options.name)\n  }\n\n  if (typeof template === 'function') {\n    templateFunc = template\n  } else {\n    templateFunc = compile(template, options)\n  }\n\n  if (options.cache && options.name) {\n    options.storage.templates.define(options.name, templateFunc)\n  }\n\n  return templateFunc\n}\n\nexport default function render (\n  template: string | TemplateFunction,\n  data: object,\n  env?: PartialConfig,\n  cb?: CallbackFn\n) {\n  var options = getConfig(env || {})\n\n  if (options.async) {\n    var result\n    if (!cb) {\n      // No callback, try returning a promise\n      if (typeof promiseImpl === 'function') {\n        return new promiseImpl(function (resolve: Function, reject: Function) {\n          try {\n            result = handleCache(template, options)(data, options)\n            resolve(result)\n          } catch (err) {\n            reject(err)\n          }\n        })\n      } else {\n        throw SqrlErr(\"Please provide a callback function, this env doesn't support Promises\")\n      }\n    } else {\n      try {\n        handleCache(template, options)(data, options, cb)\n      } catch (err) {\n        return cb(err)\n      }\n    }\n  } else {\n    return handleCache(template, options)(data, options)\n  }\n}\n"],"names":["SqrlErr","message","obj","proto","err","Error","prototype","Object","setPrototypeOf","__proto__","ParseErr","str","indx","whitespace","slice","split","lineNo","length","colNo","Array","join","create","name","value","enumerable","promiseImpl","Function","Promise","asyncFunc","e","SyntaxError","hasOwnProp","prop","hasOwnProperty","call","copyProps","toObj","fromObj","notConfig","key","asyncRegExp","templateLitReg","singleQuoteReg","doubleQuoteReg","specialCharsReg","escapeRegExp","string","test","replace","parse","env","rmWhitespace","lastIndex","envPrefixes","prefixes","h","b","i","r","c","reduce","accumulator","prefix","parseCloseReg","RegExp","tags","tagOpenReg","startInd","trimNextLeftWs","parseTag","tagOpenIndex","currentType","m","currentObj","f","numParens","currentAttribute","addAttrValue","valUnprocessed","val","trim","raw","async","push","found","search","exec","char","punctuator","tagClose","slash","wsControl","index","commentCloseInd","indexOf","t","parseResult","parseContext","parentObj","firstParse","d","tagOpenMatch","lastBlock","buffer","pushString","strng","shouldTrimRightOfString","wsLeft","wsRight","leftTrim","rightTrim","autoTrim","isArray","String","trimLeft","trimRight","trimWS","prefixType","precedingString","shouldTrimRightPrecedingString","hName","n","a","blockName","selfClosingHName","plugins","plugin","processAST","compileToString","Parse","res","useWith","varName","compileScope","processFnString","filter","filters","params","compileHelper","descendants","isAsync","ret","compileScopeIntoFunction","compileBlocks","blocks","block","p","buff","buffLength","returnStr","currentBlock","type","content","defaultFilter","filtered","autoEscape","storage","nativeHelpers","get","helperReturn","cache","this","Cacher","cacheObj","errWithBlocksOrFilters","native","escMap","&","<",">","\"","'","replaceChar","s","templates","helpers","each","arr","resolve","asyncArrLoop","fn","cb","then","foreach","asyncObjLoop","keys","include","config","template","extends","data","useScope","if","try","newStr","defaultConfig","l","container","hRet","fRet","getConfig","override","baseConfig","bind","compile","options","ctor","handleCache","templateFunc","define","reject"],"mappings":"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"}