@nanoporetech-digital/components 5.9.6 → 5.11.0

package/dist/cjs/nano-algolia.cjs.entry.js

@@ -5,13 +5,12 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-const index = require('./index-1d3ebe1a.js');
-const algoliasearchLite_esm_browser = require('./algoliasearch-lite.esm.browser-992a2eff.js');
+const index = require('./index-14451c95.js');
+const algoliasearchLite_esm_browser = require('./algoliasearch-lite.esm.browser-b74ca774.js');
 const dom = require('./dom-1d35ea4d.js');
-const componentStore = require('./component-store-6d7b8855.js');
-const _commonjsHelpers = require('./_commonjsHelpers-29614748.js');
+const componentStore = require('./component-store-149aeffe.js');
 const throttle = require('./throttle-dfa64b9e.js');
-const algoliaData = require('./algolia-data-6841724e.js');
+const algoliaData = require('./algolia-data-dba27b97.js');
 
 var multiverse = new Map();
 var updateConsumer = function (_a, state) {
@@ -134,19 +133,977 @@ class PromiseQueue {
 }
 PromiseQueue.pendingPromise = false;
 
-var squirrelly_min = _commonjsHelpers.createCommonjsModule(function (module, exports) {
-!function(e,t){t(exports);}(_commonjsHelpers.commonjsGlobal,(function(e){function t(e){var n,r,a=new Error(e);return n=a,r=t.prototype,Object.setPrototypeOf?Object.setPrototypeOf(n,r):n.__proto__=r,a}function n(e,n,r){var a=n.slice(0,r).split(/\n/),i=a.length,s=a[i-1].length+1;throw t(e+=" at line "+i+" col "+s+":\n\n  "+n.split(/\n/)[i-1]+"\n  "+Array(s).join(" ")+"^")}t.prototype=Object.create(Error.prototype,{name:{value:"Squirrelly Error",enumerable:!1}});var r=new Function("return this")().Promise,a=!1;try{a=new Function("return (async function(){}).constructor")();}catch(e){if(!(e instanceof SyntaxError))throw e}function i(e,t){return Object.prototype.hasOwnProperty.call(e,t)}function s(e,t,n){for(var r in t)i(t,r)&&(null==t[r]||"object"!=typeof t[r]||"storage"!==r&&"prefixes"!==r||n?e[r]=t[r]:e[r]=s({},t[r]));return e}var c=/^async +/,o=/`(?:\\[\s\S]|\${(?:[^{}]|{(?:[^{}]|{[^}]*})*})*}|(?!\${)[^\\`])*`/g,l=/'(?:\\[\s\w"'\\`]|[^\n\r'\\])*?'/g,f=/"(?:\\[\s\w"'\\`]|[^\n\r"\\])*?"/g,u=/[.*+\-?^${}()|[\]\\]/g;function p(e){return u.test(e)?e.replace(u,"\\$&"):e}function h(e,r){r.rmWhitespace&&(e=e.replace(/[\r\n]+/g,"\n").replace(/^\s+|\s+$/gm,"")),o.lastIndex=0,l.lastIndex=0,f.lastIndex=0;var a=r.prefixes,i=[a.h,a.b,a.i,a.r,a.c,a.e].reduce((function(e,t){return e&&t?e+"|"+p(t):t?p(t):e}),""),s=new RegExp("([|()]|=>)|('|\"|`|\\/\\*)|\\s*((\\/)?(-|_)?"+p(r.tags[1])+")","g"),u=new RegExp("([^]*?)"+p(r.tags[0])+"(-|_)?\\s*("+i+")?\\s*","g"),h=0,d=!1;function g(t,a){var i,p={f:[]},g=0,v="c";function m(t){var a=e.slice(h,t),i=a.trim();if("f"===v)"safe"===i?p.raw=!0:r.async&&c.test(i)?(i=i.replace(c,""),p.f.push([i,"",!0])):p.f.push([i,""]);else if("fp"===v)p.f[p.f.length-1][1]+=i;else if("err"===v){if(i){var s=a.search(/\S/);n("invalid syntax",e,h+s);}}else p[v]=i;h=t+1;}for("h"===a||"b"===a||"c"===a?v="n":"r"===a&&(p.raw=!0,a="i"),s.lastIndex=h;null!==(i=s.exec(e));){var y=i[1],x=i[2],b=i[3],w=i[4],F=i[5],S=i.index;if(y)"("===y?(0===g&&("n"===v?(m(S),v="p"):"f"===v&&(m(S),v="fp")),g++):")"===y?0===--g&&"c"!==v&&(m(S),v="err"):0===g&&"|"===y?(m(S),v="f"):"=>"===y&&(m(S),h+=1,v="res");else if(x){if("/*"===x){var I=e.indexOf("*/",s.lastIndex);-1===I&&n("unclosed comment",e,i.index),s.lastIndex=I+2;}else if("'"===x){l.lastIndex=i.index,l.exec(e)?s.lastIndex=l.lastIndex:n("unclosed string",e,i.index);}else if('"'===x){f.lastIndex=i.index,f.exec(e)?s.lastIndex=f.lastIndex:n("unclosed string",e,i.index);}else if("`"===x){o.lastIndex=i.index,o.exec(e)?s.lastIndex=o.lastIndex:n("unclosed string",e,i.index);}}else if(b)return m(S),h=S+i[0].length,u.lastIndex=h,d=F,w&&"h"===a&&(a="s"),p.t=a,p}return n("unclosed tag",e,t),p}var v=function i(s,o){s.b=[],s.d=[];var l,f=!1,p=[];function v(e,t){e&&(e=function(e,t,n,r){var a,i;return "string"==typeof t.autoTrim?a=i=t.autoTrim:Array.isArray(t.autoTrim)&&(a=t.autoTrim[1],i=t.autoTrim[0]),(n||!1===n)&&(a=n),(r||!1===r)&&(i=r),"slurp"===a&&"slurp"===i?e.trim():("_"===a||"slurp"===a?e=String.prototype.trimLeft?e.trimLeft():e.replace(/^[\s\uFEFF\xA0]+/,""):"-"!==a&&"nl"!==a||(e=e.replace(/^(?:\n|\r|\r\n)/,"")),"_"===i||"slurp"===i?e=String.prototype.trimRight?e.trimRight():e.replace(/[\s\uFEFF\xA0]+$/,""):"-"!==i&&"nl"!==i||(e=e.replace(/(?:\n|\r|\r\n)$/,"")),e)}(e,r,d,t))&&(e=e.replace(/\\|'/g,"\\$&").replace(/\r\n|\n|\r/g,"\\n"),p.push(e));}for(;null!==(l=u.exec(e));){var m,y=l[1],x=l[2],b=l[3]||"";for(var w in a)if(a[w]===b){m=w;break}v(y,x),h=l.index+l[0].length,m||n("unrecognized tag type: "+b,e,h);var F=g(l.index,m),S=F.t;if("h"===S){var I=F.n||"";r.async&&c.test(I)&&(F.a=!0,F.n=I.replace(c,"")),F=i(F),p.push(F);}else if("c"===S){if(s.n===F.n)return f?(f.d=p,s.b.push(f)):s.d=p,s;n("Helper start and end don't match",e,l.index+l[0].length);}else if("b"===S){f?(f.d=p,s.b.push(f)):s.d=p;var R=F.n||"";r.async&&c.test(R)&&(F.a=!0,F.n=R.replace(c,"")),f=F,p=[];}else if("s"===S){var T=F.n||"";r.async&&c.test(T)&&(F.a=!0,F.n=T.replace(c,"")),p.push(F);}else p.push(F);}if(!o)throw t('unclosed helper "'+s.n+'"');return v(e.slice(h,e.length),!1),s.d=p,s}({f:[]},!0);if(r.plugins)for(var m=0;m<r.plugins.length;m++){var y=r.plugins[m];y.processAST&&(v.d=y.processAST(v.d,r));}return v.d}function d(e,t){var n=h(e,t),r="var tR='';"+(t.useWith?"with("+t.varName+"||{}){":"")+x(n,t)+"if(cb){cb(null,tR)} return tR"+(t.useWith?"}":"");if(t.plugins)for(var a=0;a<t.plugins.length;a++){var i=t.plugins[a];i.processFnString&&(r=i.processFnString(r,t));}return r}function g(e,t){for(var n=0;n<t.length;n++){var r=t[n][0],a=t[n][1];e=(t[n][2]?"await ":"")+"c.l('F','"+r+"')("+e,a&&(e+=","+a),e+=")";}return e}function v(e,t,n,r,a,i){var s="{exec:"+(a?"async ":"")+y(n,t,e)+",params:["+r+"]";return i&&(s+=",name:'"+i+"'"),a&&(s+=",async:true"),s+="}"}function m(e,t){for(var n="[",r=0;r<e.length;r++){var a=e[r];n+=v(t,a.res||"",a.d,a.p||"",a.a,a.n),r<e.length&&(n+=",");}return n+="]"}function y(e,t,n){return "function("+t+"){var tR='';"+x(e,n)+"return tR}"}function x(e,t){for(var n=0,r=e.length,a="";n<r;n++){var i=e[n];if("string"==typeof i){a+="tR+='"+i+"';";}else {var s=i.t,c=i.c||"",o=i.f,l=i.n||"",f=i.p||"",u=i.res||"",p=i.b,h=!!i.a;if("i"===s){t.defaultFilter&&(c="c.l('F','"+t.defaultFilter+"')("+c+")");var d=g(c,o);!i.raw&&t.autoEscape&&(d="c.l('F','e')("+d+")"),a+="tR+="+d+";";}else if("h"===s)if(t.storage.nativeHelpers.get(l))a+=t.storage.nativeHelpers.get(l)(i,t);else {var y=(h?"await ":"")+"c.l('H','"+l+"')("+v(t,u,i.d,f,h);y+=p?","+m(p,t):",[]",a+="tR+="+g(y+=",c)",o)+";";}else "s"===s?a+="tR+="+g((h?"await ":"")+"c.l('H','"+l+"')({params:["+f+"]},[],c)",o)+";":"e"===s&&(a+=c+"\n");}}return a}var b=function(){function e(e){this.cache=e;}return e.prototype.define=function(e,t){this.cache[e]=t;},e.prototype.get=function(e){return this.cache[e]},e.prototype.remove=function(e){delete this.cache[e];},e.prototype.reset=function(){this.cache={};},e.prototype.load=function(e){s(this.cache,e,!0);},e}();function w(e,n,r,a){if(n&&n.length>0)throw t((a?"Native":"")+"Helper '"+e+"' doesn't accept blocks");if(r&&r.length>0)throw t((a?"Native":"")+"Helper '"+e+"' doesn't accept filters")}var F={"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"};function S(e){return F[e]}var I=new b({}),R=new b({each:function(e,t){var n="",r=e.params[0];if(w("each",t,!1),e.async)return new Promise((function(t){!function e(t,n,r,a,i){r(t[n],n).then((function(s){a+=s,n===t.length-1?i(a):e(t,n+1,r,a,i);}));}(r,0,e.exec,n,t);}));for(var a=0;a<r.length;a++)n+=e.exec(r[a],a);return n},foreach:function(e,t){var n=e.params[0];if(w("foreach",t,!1),e.async)return new Promise((function(t){!function e(t,n,r,a,i,s){a(n[r],t[n[r]]).then((function(c){i+=c,r===n.length-1?s(i):e(t,n,r+1,a,i,s);}));}(n,Object.keys(n),0,e.exec,"",t);}));var r="";for(var a in n)i(n,a)&&(r+=e.exec(a,n[a]));return r},include:function(e,n,r){w("include",n,!1);var a=r.storage.templates.get(e.params[0]);if(!a)throw t('Could not fetch template "'+e.params[0]+'"');return a(e.params[1],r)},extends:function(e,n,r){var a=e.params[1]||{};a.content=e.exec();for(var i=0;i<n.length;i++){var s=n[i];a[s.name]=s.exec();}var c=r.storage.templates.get(e.params[0]);if(!c)throw t('Could not fetch template "'+e.params[0]+'"');return c(a,r)},useScope:function(e,t){return w("useScope",t,!1),e.exec(e.params[0])}}),T=new b({if:function(e,t){w("if",!1,e.f,!0);var n="if("+e.p+"){"+x(e.d,t)+"}";if(e.b)for(var r=0;r<e.b.length;r++){var a=e.b[r];"else"===a.n?n+="else{"+x(a.d,t)+"}":"elif"===a.n&&(n+="else if("+a.p+"){"+x(a.d,t)+"}");}return n},try:function(e,n){if(w("try",!1,e.f,!0),!e.b||1!==e.b.length||"catch"!==e.b[0].n)throw t("native helper 'try' only accepts 1 block, 'catch'");var r="try{"+x(e.d,n)+"}",a=e.b[0];return r+="catch"+(a.res?"("+a.res+")":"")+"{"+x(a.d,n)+"}"},block:function(e,t){return w("block",e.b,e.f,!0),"if(!"+t.varName+"["+e.p+"]){tR+=("+y(e.d,"",t)+")()}else{tR+="+t.varName+"["+e.p+"]}"}}),E=new b({e:function(e){var t=String(e);return /[&<>"']/.test(t)?t.replace(/[&<>"']/g,S):t}}),j={varName:"it",autoTrim:[!1,"nl"],autoEscape:!0,defaultFilter:!1,tags:["{{","}}"],l:function(e,n){if("H"===e){var r=this.storage.helpers.get(n);if(r)return r;throw t("Can't find helper '"+n+"'")}if("F"===e){var a=this.storage.filters.get(n);if(a)return a;throw t("Can't find filter '"+n+"'")}},async:!1,storage:{helpers:R,nativeHelpers:T,filters:E,templates:I},prefixes:{h:"@",b:"#",i:"",r:"*",c:"/",e:"!"},cache:!1,plugins:[],useWith:!1};function H(e,t){var n={};return s(n,j),t&&s(n,t),e&&s(n,e),n.l.bind(n),n}function O(e,n){var r=H(n||{}),i=Function;if(r.async){if(!a)throw t("This environment doesn't support async/await");i=a;}try{return new i(r.varName,"c","cb",d(e,r))}catch(n){throw n instanceof SyntaxError?t("Bad template syntax\n\n"+n.message+"\n"+Array(n.message.length+1).join("=")+"\n"+d(e,r)):n}}function _(e,t){var n;return t.cache&&t.name&&t.storage.templates.get(t.name)?t.storage.templates.get(t.name):(n="function"==typeof e?e:O(e,t),t.cache&&t.name&&t.storage.templates.define(t.name,n),n)}j.l.bind(j),e.compile=O,e.compileScope=x,e.compileScopeIntoFunction=y,e.compileToString=d,e.defaultConfig=j,e.filters=E,e.getConfig=H,e.helpers=R,e.nativeHelpers=T,e.parse=h,e.render=function(e,n,a,i){var s=H(a||{});if(!s.async)return _(e,s)(n,s);if(!i){if("function"==typeof r)return new r((function(t,r){try{t(_(e,s)(n,s));}catch(e){r(e);}}));throw t("Please provide a callback function, this env doesn't support Promises")}try{_(e,s)(n,s,i);}catch(e){return i(e)}},e.templates=I,Object.defineProperty(e,"__esModule",{value:!0});}));
-//# sourceMappingURL=squirrelly.min.js.map
+function setPrototypeOf(obj, proto) {
+  if (Object.setPrototypeOf) {
+    Object.setPrototypeOf(obj, proto);
+  }
+  else {
+    obj.__proto__ = proto;
+  }
+}
+function SqrlErr(message) {
+  const err = new Error(message);
+  setPrototypeOf(err, SqrlErr.prototype);
+  return err;
+}
+SqrlErr.prototype = Object.create(Error.prototype, {
+  name: { value: 'Squirrelly Error', enumerable: false },
+});
+// TODO: Class transpilation adds a lot to the bundle size
+function ParseErr(message, str, indx) {
+  const whitespace = str.slice(0, indx).split(/\n/);
+  const lineNo = whitespace.length;
+  const colNo = whitespace[lineNo - 1].length + 1;
+  message +=
+    ' at line ' +
+      lineNo +
+      ' col ' +
+      colNo +
+      ':\n\n' +
+      '  ' +
+      str.split(/\n/)[lineNo - 1] +
+      '\n' +
+      '  ' +
+      Array(colNo).join(' ') +
+      '^';
+  throw SqrlErr(message);
+}
+
+// TODO: allow '-' to trim up until newline. Use [^\S\n\r] instead of \s
+// TODO: only include trimLeft polyfill if not in ES6
+/* END TYPES */
+const promiseImpl = new Function('return this')().Promise;
+let asyncFunc = false;
+try {
+  asyncFunc = new Function('return (async function(){}).constructor')();
+}
+catch (e) {
+  // We shouldn't actually ever have any other errors, but...
+  if (!(e instanceof SyntaxError)) {
+    throw e;
+  }
+}
+function hasOwnProp(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+function copyProps(toObj, fromObj, notConfig) {
+  for (const key in fromObj) {
+    if (hasOwnProp(fromObj, key)) {
+      if (fromObj[key] != null &&
+        typeof fromObj[key] == 'object' &&
+        (key === 'storage' || key === 'prefixes') &&
+        !notConfig // not called from Cache.load
+      ) {
+        // plugins or storage
+        // Note: this doesn't merge from initial config!
+        // Deep clone instead of assigning
+        // TODO: run checks on this
+        toObj[key] = copyProps(
+        /*toObj[key] ||*/ {}, fromObj[key]);
+      }
+      else {
+        toObj[key] = fromObj[key];
+      }
+    }
+  }
+  return toObj;
+}
+function trimWS(str, env, wsLeft, wsRight) {
+  let leftTrim;
+  let rightTrim;
+  if (typeof env.autoTrim === 'string') {
+    leftTrim = rightTrim = env.autoTrim;
+    // Don't need to check if env.autoTrim is false
+    // Because leftTrim, rightTrim are initialized as falsy
+  }
+  else if (Array.isArray(env.autoTrim)) {
+    // kinda confusing
+    // but _}} will trim the left side of the following string
+    leftTrim = env.autoTrim[1];
+    rightTrim = env.autoTrim[0];
+  }
+  if (wsLeft || wsLeft === false) {
+    leftTrim = wsLeft;
+  }
+  if (wsRight || wsRight === false) {
+    rightTrim = wsRight;
+  }
+  if (leftTrim === 'slurp' && rightTrim === 'slurp') {
+    return str.trim();
+  }
+  if (leftTrim === '_' || leftTrim === 'slurp') {
+    // console.log('trimming left' + leftTrim)
+    // full slurp
+    // eslint-disable-next-line no-extra-boolean-cast
+    if (!!String.prototype.trimLeft) {
+      str = str.trimLeft();
+    }
+    else {
+      str = str.replace(/^[\s\uFEFF\xA0]+/, '');
+    }
+  }
+  else if (leftTrim === '-' || leftTrim === 'nl') {
+    // console.log('trimming left nl' + leftTrim)
+    // nl trim
+    str = str.replace(/^(?:\n|\r|\r\n)/, '');
+  }
+  if (rightTrim === '_' || rightTrim === 'slurp') {
+    // console.log('trimming right' + rightTrim)
+    // full slurp
+    // eslint-disable-next-line no-extra-boolean-cast
+    if (!!String.prototype.trimRight) {
+      str = str.trimRight();
+    }
+    else {
+      str = str.replace(/[\s\uFEFF\xA0]+$/, '');
+    }
+  }
+  else if (rightTrim === '-' || rightTrim === 'nl') {
+    // console.log('trimming right nl' + rightTrim)
+    // nl trim
+    str = str.replace(/(?:\n|\r|\r\n)$/, ''); // TODO: make sure this gets \r\n
+  }
+  return str;
+}
+
+/* END TYPES */
+const asyncRegExp = /^async +/;
+const templateLitReg = /`(?:\\[\s\S]|\${(?:[^{}]|{(?:[^{}]|{[^}]*})*})*}|(?!\${)[^\\`])*`/g;
+const singleQuoteReg = /'(?:\\[\s\w"'\\`]|[^\n\r'\\])*?'/g;
+const doubleQuoteReg = /"(?:\\[\s\w"'\\`]|[^\n\r"\\])*?"/g;
+const specialCharsReg = /[.*+\-?^${}()|[\]\\]/g;
+function escapeRegExp(string) {
+  // From MDN
+  return specialCharsReg.test(string)
+    ? string.replace(specialCharsReg, '\\$&') // $& means the whole matched string
+    : string;
+}
+function parse(str, env) {
+  /* Adding for EJS compatibility */
+  if (env.rmWhitespace) {
+    // Code taken directly from EJS
+    // Have to use two separate replaces here as `^` and `$` operators don't
+    // work well with `\r` and empty lines don't work well with the `m` flag.
+    // Essentially, this replaces the whitespace at the beginning and end of
+    // each line and removes multiple newlines.
+    str = str.replace(/[\r\n]+/g, '\n').replace(/^\s+|\s+$/gm, '');
+  }
+  /* End rmWhitespace option */
+  templateLitReg.lastIndex = 0;
+  singleQuoteReg.lastIndex = 0;
+  doubleQuoteReg.lastIndex = 0;
+  const envPrefixes = env.prefixes;
+  const prefixes = [
+    envPrefixes.h,
+    envPrefixes.b,
+    envPrefixes.i,
+    envPrefixes.r,
+    envPrefixes.c,
+    envPrefixes.e,
+  ].reduce(function (accumulator, prefix) {
+    if (accumulator && prefix) {
+      return accumulator + '|' + escapeRegExp(prefix);
+    }
+    else if (prefix) {
+      // accumulator is empty
+      return escapeRegExp(prefix);
+    }
+    else {
+      // prefix and accumulator are both empty strings
+      return accumulator;
+    }
+  }, '');
+  const parseCloseReg = new RegExp('([|()]|=>)|' + // powerchars
+    '(\'|"|`|\\/\\*)|\\s*((\\/)?(-|_)?' + // comments, strings
+    escapeRegExp(env.tags[1]) +
+    ')', 'g');
+  const tagOpenReg = new RegExp('([^]*?)' + escapeRegExp(env.tags[0]) + '(-|_)?\\s*(' + prefixes + ')?\\s*', 'g');
+  let startInd = 0;
+  let trimNextLeftWs = false;
+  function parseTag(tagOpenIndex, currentType) {
+    const currentObj = { f: [] };
+    let numParens = 0;
+    let currentAttribute = 'c'; // default - Valid values: 'c'=content, 'f'=filter, 'fp'=filter params, 'p'=param, 'n'=name
+    if (currentType === 'h' || currentType === 'b' || currentType === 'c') {
+      currentAttribute = 'n';
+    }
+    else if (currentType === 'r') {
+      currentObj.raw = true;
+      currentType = 'i';
+    }
+    function addAttrValue(indx) {
+      const valUnprocessed = str.slice(startInd, indx);
+      // console.log(valUnprocessed)
+      let val = valUnprocessed.trim();
+      if (currentAttribute === 'f') {
+        if (val === 'safe') {
+          currentObj.raw = true;
+        }
+        else {
+          if (env.async && asyncRegExp.test(val)) {
+            val = val.replace(asyncRegExp, '');
+            currentObj.f.push([val, '', true]);
+          }
+          else {
+            currentObj.f.push([val, '']);
+          }
+        }
+      }
+      else if (currentAttribute === 'fp') {
+        currentObj.f[currentObj.f.length - 1][1] += val;
+      }
+      else if (currentAttribute === 'err') {
+        if (val) {
+          const found = valUnprocessed.search(/\S/);
+          ParseErr('invalid syntax', str, startInd + found);
+        }
+      }
+      else {
+        // if (currentObj[currentAttribute]) { // TODO make sure no errs
+        //   currentObj[currentAttribute] += val
+        // } else {
+        currentObj[currentAttribute] = val;
+        // }
+      }
+      startInd = indx + 1;
+    }
+    parseCloseReg.lastIndex = startInd;
+    let m;
+    // tslint:disable-next-line:no-conditional-assignment
+    while ((m = parseCloseReg.exec(str)) !== null) {
+      const char = m[1];
+      const punctuator = m[2];
+      const tagClose = m[3];
+      const slash = m[4];
+      const wsControl = m[5];
+      const i = m.index;
+      if (char) {
+        // Power character
+        if (char === '(') {
+          if (numParens === 0) {
+            if (currentAttribute === 'n') {
+              addAttrValue(i);
+              currentAttribute = 'p';
+            }
+            else if (currentAttribute === 'f') {
+              addAttrValue(i);
+              currentAttribute = 'fp';
+            }
+          }
+          numParens++;
+        }
+        else if (char === ')') {
+          numParens--;
+          if (numParens === 0 && currentAttribute !== 'c') {
+            // Then it's closing a filter, block, or helper
+            addAttrValue(i);
+            currentAttribute = 'err'; // Reset the current attribute
+          }
+        }
+        else if (numParens === 0 && char === '|') {
+          addAttrValue(i); // this should actually always be whitespace or empty
+          currentAttribute = 'f';
+        }
+        else if (char === '=>') {
+          addAttrValue(i);
+          startInd += 1; // this is 2 chars
+          currentAttribute = 'res';
+        }
+      }
+      else if (punctuator) {
+        if (punctuator === '/*') {
+          const commentCloseInd = str.indexOf('*/', parseCloseReg.lastIndex);
+          if (commentCloseInd === -1) {
+            ParseErr('unclosed comment', str, m.index);
+          }
+          parseCloseReg.lastIndex = commentCloseInd + 2; // since */ is 2 characters, and we're using indexOf rather than a RegExp
+        }
+        else if (punctuator === "'") {
+          singleQuoteReg.lastIndex = m.index;
+          const singleQuoteMatch = singleQuoteReg.exec(str);
+          if (singleQuoteMatch) {
+            parseCloseReg.lastIndex = singleQuoteReg.lastIndex;
+          }
+          else {
+            ParseErr('unclosed string', str, m.index);
+          }
+        }
+        else if (punctuator === '"') {
+          doubleQuoteReg.lastIndex = m.index;
+          const doubleQuoteMatch = doubleQuoteReg.exec(str);
+          if (doubleQuoteMatch) {
+            parseCloseReg.lastIndex = doubleQuoteReg.lastIndex;
+          }
+          else {
+            ParseErr('unclosed string', str, m.index);
+          }
+        }
+        else if (punctuator === '`') {
+          templateLitReg.lastIndex = m.index;
+          const templateLitMatch = templateLitReg.exec(str);
+          if (templateLitMatch) {
+            parseCloseReg.lastIndex = templateLitReg.lastIndex;
+          }
+          else {
+            ParseErr('unclosed string', str, m.index);
+          }
+        }
+      }
+      else if (tagClose) {
+        addAttrValue(i);
+        startInd = i + m[0].length;
+        tagOpenReg.lastIndex = startInd;
+        // console.log('tagClose: ' + startInd)
+        trimNextLeftWs = wsControl;
+        if (slash && currentType === 'h') {
+          currentType = 's';
+        } // TODO throw err
+        currentObj.t = currentType;
+        return currentObj;
+      }
+    }
+    ParseErr('unclosed tag', str, tagOpenIndex);
+    return currentObj; // To prevent TypeScript from erroring
+  }
+  function parseContext(parentObj, firstParse) {
+    parentObj.b = []; // assume there will be blocks // TODO: perf optimize this
+    parentObj.d = [];
+    let lastBlock = false;
+    let buffer = [];
+    function pushString(strng, shouldTrimRightOfString) {
+      if (strng) {
+        // if string is truthy it must be of type 'string'
+        // TODO: benchmark replace( /(\\|')/g, '\\$1')
+        strng = trimWS(strng, env, trimNextLeftWs, // this will only be false on the first str, the next ones will be null or undefined
+        shouldTrimRightOfString);
+        if (strng) {
+          // replace \ with \\, ' with \'
+          strng = strng.replace(/\\|'/g, '\\$&').replace(/\r\n|\n|\r/g, '\\n');
+          // we're going to convert all CRLF to LF so it doesn't take more than one replace
+          buffer.push(strng);
+        }
+      }
+    }
+    // Random TODO: parentObj.b doesn't need to have t: #
+    let tagOpenMatch;
+    // tslint:disable-next-line:no-conditional-assignment
+    while ((tagOpenMatch = tagOpenReg.exec(str)) !== null) {
+      const precedingString = tagOpenMatch[1];
+      const shouldTrimRightPrecedingString = tagOpenMatch[2];
+      const prefix = tagOpenMatch[3] || '';
+      let prefixType;
+      for (const key in envPrefixes) {
+        if (envPrefixes[key] === prefix) {
+          prefixType = key;
+          break;
+        }
+      }
+      pushString(precedingString, shouldTrimRightPrecedingString);
+      startInd = tagOpenMatch.index + tagOpenMatch[0].length;
+      if (!prefixType) {
+        ParseErr('unrecognized tag type: ' + prefix, str, startInd);
+      }
+      let currentObj = parseTag(tagOpenMatch.index, prefixType);
+      // ===== NOW ADD THE OBJECT TO OUR BUFFER =====
+      const currentType = currentObj.t;
+      if (currentType === 'h') {
+        const hName = currentObj.n || '';
+        if (env.async && asyncRegExp.test(hName)) {
+          currentObj.a = true;
+          currentObj.n = hName.replace(asyncRegExp, '');
+        }
+        currentObj = parseContext(currentObj); // currentObj is the parent object
+        buffer.push(currentObj);
+      }
+      else if (currentType === 'c') {
+        // tag close
+        if (parentObj.n === currentObj.n) {
+          if (lastBlock) {
+            // If there's a previous block
+            lastBlock.d = buffer;
+            parentObj.b.push(lastBlock);
+          }
+          else {
+            parentObj.d = buffer;
+          }
+          // console.log('parentObj: ' + JSON.stringify(parentObj))
+          return parentObj;
+        }
+        else {
+          ParseErr("Helper start and end don't match", str, tagOpenMatch.index + tagOpenMatch[0].length);
+        }
+      }
+      else if (currentType === 'b') {
+        // block
+        // TODO: make sure async stuff inside blocks are recognized
+        if (lastBlock) {
+          // If there's a previous block
+          lastBlock.d = buffer;
+          parentObj.b.push(lastBlock);
+        }
+        else {
+          parentObj.d = buffer;
+        }
+        const blockName = currentObj.n || '';
+        if (env.async && asyncRegExp.test(blockName)) {
+          currentObj.a = true;
+          currentObj.n = blockName.replace(asyncRegExp, '');
+        }
+        lastBlock = currentObj; // Set the 'lastBlock' object to the value of the current block
+        buffer = [];
+      }
+      else if (currentType === 's') {
+        const selfClosingHName = currentObj.n || '';
+        if (env.async && asyncRegExp.test(selfClosingHName)) {
+          currentObj.a = true;
+          currentObj.n = selfClosingHName.replace(asyncRegExp, '');
+        }
+        buffer.push(currentObj);
+      }
+      else {
+        buffer.push(currentObj);
+      }
+      // ===== DONE ADDING OBJECT TO BUFFER =====
+    }
+    if (firstParse) {
+      pushString(str.slice(startInd, str.length), false);
+      parentObj.d = buffer;
+    }
+    else {
+      throw SqrlErr('unclosed helper "' + parentObj.n + '"');
+      // It should have returned by now
+    }
+    return parentObj;
+  }
+  const parseResult = parseContext({ f: [] }, true);
+  // console.log(JSON.stringify(parseResult))
+  if (env.plugins) {
+    for (let i = 0; i < env.plugins.length; i++) {
+      const plugin = env.plugins[i];
+      if (plugin.processAST) {
+        parseResult.d = plugin.processAST(parseResult.d, env);
+      }
+    }
+  }
+  return parseResult.d; // Parse the very outside context
+}
+
+// import SqrlErr from './err'
+/* END TYPES */
+function compileToString(str, env) {
+  const buffer = parse(str, env);
+  let res = "var tR='';" +
+    (env.useWith ? 'with(' + env.varName + '||{}){' : '') +
+    compileScope(buffer, env) +
+    'if(cb){cb(null,tR)} return tR' +
+    (env.useWith ? '}' : '');
+  if (env.plugins) {
+    for (let i = 0; i < env.plugins.length; i++) {
+      const plugin = env.plugins[i];
+      if (plugin.processFnString) {
+        res = plugin.processFnString(res, env);
+      }
+    }
+  }
+  return res;
+  // TODO: is `return cb()` necessary, or could we just do `cb()`
+}
+function filter(str, filters) {
+  for (let i = 0; i < filters.length; i++) {
+    const name = filters[i][0];
+    const params = filters[i][1];
+    const isFilterAsync = filters[i][2];
+    // if (isFilterAsync && !env.async) {
+    //   throw SqrlErr("Async filter '" + name + "' in non-async env")
+    // }
+    // Let the JS compiler do this, compile() will catch it
+    str = (isFilterAsync ? 'await ' : '') + "c.l('F','" + name + "')(" + str;
+    if (params) {
+      str += ',' + params;
+    }
+    str += ')';
+  }
+  return str;
+}
+// TODO: Use type intersections for TemplateObject, etc.
+// so I don't have to make properties mandatory
+function compileHelper(env, res, descendants, params, isAsync, name) {
+  let ret = '{exec:' +
+    (isAsync ? 'async ' : '') +
+    compileScopeIntoFunction(descendants, res, env) +
+    ',params:[' +
+    params +
+    ']';
+  if (name) {
+    ret += ",name:'" + name + "'";
+  }
+  if (isAsync) {
+    ret += ',async:true';
+  }
+  ret += '}';
+  return ret;
+}
+function compileBlocks(blocks, env) {
+  let ret = '[';
+  for (let i = 0; i < blocks.length; i++) {
+    const block = blocks[i];
+    ret += compileHelper(env, block.res || '', block.d, block.p || '', block.a, block.n);
+    if (i < blocks.length) {
+      ret += ',';
+    }
+  }
+  ret += ']';
+  return ret;
+}
+function compileScopeIntoFunction(buff, res, env) {
+  return ('function(' + res + "){var tR='';" + compileScope(buff, env) + 'return tR}');
+}
+function compileScope(buff, env) {
+  let i = 0;
+  const buffLength = buff.length;
+  let returnStr = '';
+  for (i; i < buffLength; i++) {
+    const currentBlock = buff[i];
+    if (typeof currentBlock === 'string') {
+      const str = currentBlock;
+      // we know string exists
+      returnStr += "tR+='" + str + "';";
+    }
+    else {
+      const type = currentBlock.t; // h, s, e, i
+      let content = currentBlock.c || '';
+      const filters = currentBlock.f;
+      const name = currentBlock.n || '';
+      const params = currentBlock.p || '';
+      const res = currentBlock.res || '';
+      const blocks = currentBlock.b;
+      const isAsync = !!currentBlock.a; // !! is to booleanize it
+      // if (isAsync && !env.async) {
+      //   throw SqrlErr("Async block or helper '" + name + "' in non-async env")
+      // }
+      // Let compiler do this
+      if (type === 'i') {
+        if (env.defaultFilter) {
+          content = "c.l('F','" + env.defaultFilter + "')(" + content + ')';
+        }
+        let filtered = filter(content, filters);
+        if (!currentBlock.raw && env.autoEscape) {
+          filtered = "c.l('F','e')(" + filtered + ')';
+        }
+        returnStr += 'tR+=' + filtered + ';';
+        // reference
+      }
+      else if (type === 'h') {
+        // helper
+        if (env.storage.nativeHelpers.get(name)) {
+          returnStr += env.storage.nativeHelpers.get(name)(currentBlock, env);
+        }
+        else {
+          let helperReturn = (isAsync ? 'await ' : '') +
+            "c.l('H','" +
+            name +
+            "')(" +
+            compileHelper(env, res, currentBlock.d, params, isAsync);
+          if (blocks) {
+            helperReturn += ',' + compileBlocks(blocks, env);
+          }
+          else {
+            helperReturn += ',[]';
+          }
+          helperReturn += ',c)';
+          returnStr += 'tR+=' + filter(helperReturn, filters) + ';';
+        }
+      }
+      else if (type === 's') {
+        // self-closing helper
+        returnStr +=
+          'tR+=' +
+            filter((isAsync ? 'await ' : '') +
+              "c.l('H','" +
+              name +
+              "')({params:[" +
+              params +
+              ']},[],c)', filters) +
+            ';';
+      }
+      else if (type === 'e') {
+        // execute
+        returnStr += content + '\n';
+      }
+    }
+  }
+  return returnStr;
+}
+
+/* END TYPES */
+class Cacher {
+  constructor(cache) {
+    this.cache = cache;
+  }
+  define(key, val) {
+    this.cache[key] = val;
+  }
+  get(key) {
+    // string | array.
+    // TODO: allow array of keys to look down
+    // TODO: create plugin to allow referencing helpers, filters with dot notation
+    return this.cache[key];
+  }
+  remove(key) {
+    delete this.cache[key];
+  }
+  reset() {
+    this.cache = {};
+  }
+  load(cacheObj) {
+    // TODO: this will err with deep objects and `storage` or `plugins` keys.
+    // Update Feb 26: EDITED so it shouldn't err
+    copyProps(this.cache, cacheObj, true);
+  }
+}
+
+function errWithBlocksOrFilters(name, blocks, // false means don't check
+filters, native) {
+  if (blocks && blocks.length > 0) {
+    throw SqrlErr((native ? 'Native' : '') + "Helper '" + name + "' doesn't accept blocks");
+  }
+  if (filters && filters.length > 0) {
+    throw SqrlErr((native ? 'Native' : '') + "Helper '" + name + "' doesn't accept filters");
+  }
+}
+/* ASYNC LOOP FNs */
+function asyncArrLoop(arr, index, fn, res, cb) {
+  fn(arr[index], index).then(function (val) {
+    res += val;
+    if (index === arr.length - 1) {
+      cb(res);
+    }
+    else {
+      asyncArrLoop(arr, index + 1, fn, res, cb);
+    }
+  });
+}
+function asyncObjLoop(obj, keys, index, fn, res, cb) {
+  fn(keys[index], obj[keys[index]]).then(function (val) {
+    res += val;
+    if (index === keys.length - 1) {
+      cb(res);
+    }
+    else {
+      asyncObjLoop(obj, keys, index + 1, fn, res, cb);
+    }
+  });
+}
+const escMap = {
+  '&': '&amp;',
+  '<': '&lt;',
+  '>': '&gt;',
+  '"': '&quot;',
+  "'": '&#39;',
+};
+function replaceChar(s) {
+  return escMap[s];
+}
+function XMLEscape(str) {
+  // To deal with XSS. Based on Escape implementations of Mustache.JS and Marko, then customized.
+  const newStr = String(str);
+  if (/[&<>"']/.test(newStr)) {
+    return newStr.replace(/[&<>"']/g, replaceChar);
+  }
+  else {
+    return newStr;
+  }
+}
+
+/* END TYPES */
+const templates = new Cacher({});
+/* ASYNC LOOP FNs */
+const helpers = new Cacher({
+  each: function (content, blocks) {
+    let res = '';
+    const arr = content.params[0];
+    errWithBlocksOrFilters('each', blocks, false);
+    if (content.async) {
+      return new Promise(function (resolve) {
+        asyncArrLoop(arr, 0, content.exec, res, resolve);
+      });
+    }
+    else {
+      for (let i = 0; i < arr.length; i++) {
+        res += content.exec(arr[i], i);
+      }
+      return res;
+    }
+  },
+  foreach: function (content, blocks) {
+    const obj = content.params[0];
+    errWithBlocksOrFilters('foreach', blocks, false);
+    if (content.async) {
+      return new Promise(function (resolve) {
+        asyncObjLoop(obj, Object.keys(obj), 0, content.exec, '', resolve);
+      });
+    }
+    else {
+      let res = '';
+      for (const key in obj) {
+        if (!hasOwnProp(obj, key))
+          continue;
+        res += content.exec(key, obj[key]); // todo: check on order
+      }
+      return res;
+    }
+  },
+  include: function (content, blocks, config) {
+    errWithBlocksOrFilters('include', blocks, false);
+    const template = config.storage.templates.get(content.params[0]);
+    if (!template) {
+      throw SqrlErr('Could not fetch template "' + content.params[0] + '"');
+    }
+    return template(content.params[1], config);
+  },
+  extends: function (content, blocks, config) {
+    const data = content.params[1] || {};
+    data.content = content.exec();
+    for (let i = 0; i < blocks.length; i++) {
+      const currentBlock = blocks[i];
+      data[currentBlock.name] = currentBlock.exec();
+    }
+    const template = config.storage.templates.get(content.params[0]);
+    if (!template) {
+      throw SqrlErr('Could not fetch template "' + content.params[0] + '"');
+    }
+    return template(data, config);
+  },
+  useScope: function (content, blocks) {
+    errWithBlocksOrFilters('useScope', blocks, false);
+    return content.exec(content.params[0]);
+  },
 });
+const nativeHelpers = new Cacher({
+  if: function (buffer, env) {
+    errWithBlocksOrFilters('if', false, buffer.f, true);
+    let returnStr = 'if(' + buffer.p + '){' + compileScope(buffer.d, env) + '}';
+    if (buffer.b) {
+      for (let i = 0; i < buffer.b.length; i++) {
+        const currentBlock = buffer.b[i];
+        if (currentBlock.n === 'else') {
+          returnStr += 'else{' + compileScope(currentBlock.d, env) + '}';
+        }
+        else if (currentBlock.n === 'elif') {
+          returnStr +=
+            'else if(' +
+              currentBlock.p +
+              '){' +
+              compileScope(currentBlock.d, env) +
+              '}';
+        }
+      }
+    }
+    return returnStr;
+  },
+  try: function (buffer, env) {
+    errWithBlocksOrFilters('try', false, buffer.f, true);
+    if (!buffer.b || buffer.b.length !== 1 || buffer.b[0].n !== 'catch') {
+      throw SqrlErr("native helper 'try' only accepts 1 block, 'catch'");
+    }
+    let returnStr = 'try{' + compileScope(buffer.d, env) + '}';
+    const currentBlock = buffer.b[0];
+    returnStr +=
+      'catch' +
+        (currentBlock.res ? '(' + currentBlock.res + ')' : '') +
+        '{' +
+        compileScope(currentBlock.d, env) +
+        '}';
+    return returnStr;
+  },
+  block: function (buffer, env) {
+    errWithBlocksOrFilters('block', buffer.b, buffer.f, true);
+    const returnStr = 'if(!' +
+      env.varName +
+      '[' +
+      buffer.p +
+      ']){tR+=(' +
+      compileScopeIntoFunction(buffer.d, '', env) +
+      ')()}else{tR+=' +
+      env.varName +
+      '[' +
+      buffer.p +
+      ']}';
+    return returnStr;
+  },
+});
+const filters = new Cacher({ e: XMLEscape });
+
+/* END TYPES */
+const defaultConfig = {
+  varName: 'it',
+  autoTrim: [false, 'nl'],
+  autoEscape: true,
+  defaultFilter: false,
+  tags: ['{{', '}}'],
+  l: function (container, name) {
+    if (container === 'H') {
+      const hRet = this.storage.helpers.get(name);
+      if (hRet) {
+        return hRet;
+      }
+      else {
+        throw SqrlErr("Can't find helper '" + name + "'");
+      }
+    }
+    else if (container === 'F') {
+      const fRet = this.storage.filters.get(name);
+      if (fRet) {
+        return fRet;
+      }
+      else {
+        throw SqrlErr("Can't find filter '" + name + "'");
+      }
+    }
+  },
+  async: false,
+  storage: {
+    helpers: helpers,
+    nativeHelpers: nativeHelpers,
+    filters: filters,
+    templates: templates,
+  },
+  prefixes: {
+    h: '@',
+    b: '#',
+    i: '',
+    r: '*',
+    c: '/',
+    e: '!',
+  },
+  cache: false,
+  plugins: [],
+  useWith: false,
+};
+defaultConfig.l.bind(defaultConfig);
+function getConfig(override, baseConfig) {
+  // TODO: run more tests on this
+  const res = {}; // Linked
+  copyProps(res, defaultConfig); // Creates deep clone of res, 1 layer deep
+  if (baseConfig) {
+    copyProps(res, baseConfig);
+  }
+  if (override) {
+    copyProps(res, override);
+  }
+  res.l.bind(res);
+  return res;
+}
+
+/* END TYPES */
+function compile(str, env) {
+  const options = getConfig(env || {});
+  let ctor = Function; // constructor
+  /* ASYNC HANDLING */
+  // The below code is modified from mde/ejs. All credit should go to them.
+  if (options.async) {
+    // Have to use generated function for this, since in envs without support,
+    // it breaks in parsing
+    if (asyncFunc) {
+      ctor = asyncFunc;
+    }
+    else {
+      throw SqrlErr("This environment doesn't support async/await");
+    }
+  }
+  /* END ASYNC HANDLING */
+  try {
+    return new ctor(options.varName, 'c', // SqrlConfig
+    'cb', // optional callback
+    compileToString(str, options)); // eslint-disable-line no-new-func
+  }
+  catch (e) {
+    if (e instanceof SyntaxError) {
+      throw SqrlErr('Bad template syntax\n\n' +
+        e.message +
+        '\n' +
+        Array(e.message.length + 1).join('=') +
+        '\n' +
+        compileToString(str, options));
+    }
+    else {
+      throw e;
+    }
+  }
+}
 
-const squirrelly_min$1 = /*@__PURE__*/_commonjsHelpers.getDefaultExportFromCjs(squirrelly_min);
+/* TYPES */
+/* END TYPES */
+function handleCache(template, options) {
+  let templateFunc;
+  if (options.cache &&
+    options.name &&
+    options.storage.templates.get(options.name)) {
+    return options.storage.templates.get(options.name);
+  }
+  if (typeof template === 'function') {
+    templateFunc = template;
+  }
+  else {
+    templateFunc = compile(template, options);
+  }
+  if (options.cache && options.name) {
+    options.storage.templates.define(options.name, templateFunc);
+  }
+  return templateFunc;
+}
+function render(template, data, env, cb) {
+  const options = getConfig(env || {});
+  if (options.async) {
+    let result;
+    if (!cb) {
+      // No callback, try returning a promise
+      if (typeof promiseImpl === 'function') {
+        return new promiseImpl(function (resolve, reject) {
+          try {
+            result = handleCache(template, options)(data, options);
+            resolve(result);
+          }
+          catch (err) {
+            reject(err);
+          }
+        });
+      }
+      else {
+        throw SqrlErr("Please provide a callback function, this env doesn't support Promises");
+      }
+    }
+    else {
+      try {
+        handleCache(template, options)(data, options, cb);
+      }
+      catch (err) {
+        return cb(err);
+      }
+    }
+  }
+  else {
+    return handleCache(template, options)(data, options);
+  }
+}
 
-const Sqrl = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(null), squirrelly_min, {
-    'default': squirrelly_min$1
-}));
+const squirrel = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    compileToString: compileToString,
+    compileScope: compileScope,
+    compileScopeIntoFunction: compileScopeIntoFunction,
+    compile: compile,
+    parse: parse,
+    render: render,
+    helpers: helpers,
+    nativeHelpers: nativeHelpers,
+    filters: filters,
+    templates: templates,
+    defaultConfig: defaultConfig,
+    getConfig: getConfig
+});
 
-const squirrel = Sqrl;
-squirrel.filters.define('date_long', (str, options = {
+filters.define('date_long', (str, options = {
   year: 'numeric',
   month: 'long',
   day: 'numeric',
@@ -157,7 +1114,7 @@ squirrel.filters.define('date_long', (str, options = {
   str = date.toLocaleDateString('en-GB', options);
   return str;
 });
-squirrel.filters.define('date_short', (str, format = 'd/m/y') => {
+filters.define('date_short', (str, format = 'd/m/y') => {
   if (!str)
     return;
   const date = new Date(parseInt(str) * 1000);
@@ -166,7 +1123,7 @@ squirrel.filters.define('date_short', (str, format = 'd/m/y') => {
   str = str.replace(/(y)/, date.getFullYear().toString());
   return str;
 });
-squirrel.filters.define('public_name', (str) => {
+filters.define('public_name', (str) => {
   if (!str)
     return;
   str = str
@@ -177,19 +1134,19 @@ squirrel.filters.define('public_name', (str) => {
     .join(' ');
   return str.charAt(0).toUpperCase() + str.slice(1);
 });
-squirrel.filters.define('trim_to', (str, length = 100) => {
+filters.define('trim_to', (str, length = 100) => {
   if (!str)
     return;
   if (str.length <= length)
     return str;
   return str.substr(0, length) + '...';
 });
-squirrel.filters.define('classname', (str) => {
+filters.define('classname', (str) => {
   if (!str)
     return;
   return str.replace(/[\W]+/g, '');
 });
-squirrel.filters.define('abs_url', (str, index = null, result) => {
+filters.define('abs_url', (str, index = null, result) => {
   if (!index)
     return str;
   if (!str)
@@ -205,11 +1162,11 @@ squirrel.filters.define('abs_url', (str, index = null, result) => {
     return str;
   return str.match(/^http/) ? str : location.protocol + '//' + domain + str;
 });
-squirrel.filters.define('replace', (str, search, replace) => str.replace(search, replace));
-squirrel.filters.define('remove_spaces', (str) => str.replace(/ /g, '_'));
-squirrel.filters.define('add_spaces', (str) => (str = str.replace(/[_\-]/g, ' ')));
-squirrel.filters.define('capitalise', (str) => (str = str.charAt(0).toUpperCase() + str.slice(1)));
-squirrel.filters.define('lowercase', (str) => (str = str.toLowerCase()));
+filters.define('replace', (str, search, replace) => str.replace(search, replace));
+filters.define('remove_spaces', (str) => str.replace(/ /g, '_'));
+filters.define('add_spaces', (str) => (str = str.replace(/[_\-]/g, ' ')));
+filters.define('capitalise', (str) => (str = str.charAt(0).toUpperCase() + str.slice(1)));
+filters.define('lowercase', (str) => (str = str.toLowerCase()));
 const Squirrel = squirrel;
 
 const algoliaCss = ":host{box-sizing:border-box}*,*::before,*::after{box-sizing:border-box}[hidden]{display:none !important}:host{position:relative;display:block}:host ::slotted([slot=search-template]){display:none !important}.loader{opacity:0;position:fixed;block-size:100%;inline-size:100%;min-block-size:100%;max-block-size:100vh !important;max-inline-size:100vw !important;inset-inline-start:0;inset-block-start:0;z-index:-10;font-size:60px;display:flex;align-items:center;justify-content:center;transition:opacity 0.2s ease, z-index 0.01s ease 0.2s}.loader.loading{opacity:1;z-index:10;transition:z-index 0.01s ease, opacity 0.2s ease 0.01s}.default{block-size:100%}.default:focus{outline:none}.results{opacity:0;outline:none;overflow:auto;transition:transform 0.3s ease, opacity 0.3s ease, visibility 0.01s ease 0.3s, z-index 0.01s ease 0.3s;transform:translate(0, 100px);visibility:hidden;z-index:-1;position:absolute;inset-block-start:0;inset-inline-start:0;display:none}.results-container{position:relative}.results.show{transition:z-index 0.01s ease, visibility 0.01s ease, transform 0.3s ease 0.01s, opacity 0.3s ease 0.01s, overflow 0.01s ease 0.31s;transform:translate(0, 0);visibility:visible;opacity:1;z-index:10;overflow:hidden}.results.shown{block-size:auto !important;inline-size:auto !important;display:block;position:static;transform:none;z-index:auto;visibility:inherit;opacity:initial;overflow:visible}";
@@ -227,7 +1184,7 @@ const Algolia = class {
     this.dynFacetFilters = {};
     this.hasLoadSlot = false;
     this.placedAlgoliaEles = [];
-    // lots of stuff happens asynchronously. This makes sure they fire in the corrent order
+    // lots of stuff happens asynchronously. This makes sure they fire in the correct order
     this.promiseQueue = new PromiseQueue();
     this.searchChange = async () => {
       if (!this.algoliaIndex)
@@ -370,7 +1327,6 @@ const Algolia = class {
     this.inputField = undefined;
     this.algoliaIndex = undefined;
     this.indeces = [];
-    this.resultsEmitterEle = undefined;
     this.indexResults = undefined;
     this.filterChanged = '';
     this.currentHits = undefined;
@@ -387,7 +1343,6 @@ const Algolia = class {
     this.query = '';
     this.operator = 'and';
     this.filters = [];
-    this.tplEngine = Squirrel;
     this.tplRenderFn = Squirrel.render;
     this.replicaIndex = '';
     this.browseIndex = false;
@@ -395,6 +1350,14 @@ const Algolia = class {
     this.storeId = undefined;
     this.storeMethod = 'session';
   }
+  handleListenToChange() {
+    if (!this.listenTo)
+      return;
+    const foundInput = document.querySelector(this.listenTo);
+    if (['nano-input', 'input'].includes(foundInput.tagName.toLocaleLowerCase())) {
+      this.inputField = foundInput;
+    }
+  }
   // Public methods
   /**
    * @param facetName - will clear all filter selections of that type
@@ -528,6 +1491,8 @@ const Algolia = class {
     if (!this.algoliaClient || !this.searchIndex)
       return;
     if (this.searchIndex.index) {
+      if (!this.searchIndex.hitsPerPage)
+        this.searchIndex.hitsPerPage = 100;
       if (this.replicaIndex)
         this.searchIndex.index = this.replicaIndex;
       this.searchIndexName = this.searchIndex.index;
@@ -733,6 +1698,8 @@ const Algolia = class {
       else if (this.slottedInput) {
         this.inputField = this.slottedInput.querySelector('nano-input, input:not([type="radio"]):not([type="checkbox"])');
       }
+      else
+        this.handleListenToChange();
       index.writeTask((_) => {
         if (this.showResults && this.tpl)
           this.searchChange();
@@ -780,6 +1747,7 @@ const Algolia = class {
   }
   get host() { return index.getElement(this); }
   static get watchers() { return {
+    "listenTo": ["handleListenToChange"],
     "_dynFacetFilters": ["dynFacetFiltersChange"],
     "browseIndex": ["browseIndexChange"],
     "inputField": ["inputFieldSet"],