@nanoporetech-digital/components 1.13.17 → 1.13.21

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

@@ -0,0 +1,869 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const index = require('./index-43791691.js');
+const algoliaData = require('./algolia-data-771a61ea.js');
+const dom = require('./dom-2fcf8654.js');
+const throttle = require('./throttle-f9d3e6c9.js');
+const algoliasearch_umd = require('./algoliasearch.umd-51f0001d.js');
+const _commonjsHelpers = require('./_commonjsHelpers-dcc4cf71.js');
+const componentStore = require('./component-store-c8440fd7.js');
+
+var multiverse = new Map();
+var updateConsumer = function (_a, state) {
+    var fields = _a.fields, updater = _a.updater;
+    fields.forEach(function (field) { updater(field, state[field]); });
+};
+var Universe = {
+    create: function (creator, initialState) {
+        var el = index.getElement(creator);
+        var wormholes = new Map();
+        var universe = { wormholes: wormholes, state: initialState };
+        multiverse.set(creator, universe);
+        var connectedCallback = creator.connectedCallback;
+        creator.connectedCallback = function () {
+            multiverse.set(creator, universe);
+            if (connectedCallback) {
+                connectedCallback.call(creator);
+            }
+        };
+        var disconnectedCallback = creator.disconnectedCallback;
+        creator.disconnectedCallback = function () {
+            multiverse.delete(creator);
+            if (disconnectedCallback) {
+                disconnectedCallback.call(creator);
+            }
+        };
+        el.addEventListener('openWormhole', function (event) {
+            event.stopPropagation();
+            var _a = event.detail, consumer = _a.consumer, onOpen = _a.onOpen;
+            if (wormholes.has(consumer))
+                return;
+            if (typeof consumer !== 'symbol') {
+                var connectedCallback_1 = consumer.connectedCallback, disconnectedCallback_1 = consumer.disconnectedCallback;
+                consumer.connectedCallback = function () {
+                    wormholes.set(consumer, event.detail);
+                    if (connectedCallback_1) {
+                        connectedCallback_1.call(consumer);
+                    }
+                };
+                consumer.disconnectedCallback = function () {
+                    wormholes.delete(consumer);
+                    if (disconnectedCallback_1) {
+                        disconnectedCallback_1.call(consumer);
+                    }
+                };
+            }
+            wormholes.set(consumer, event.detail);
+            updateConsumer(event.detail, universe.state);
+            onOpen === null || onOpen === void 0 ? void 0 : onOpen.resolve(function () { wormholes.delete(consumer); });
+        });
+        el.addEventListener('closeWormhole', function (event) {
+            var consumer = event.detail;
+            wormholes.delete(consumer);
+        });
+    },
+    Provider: function (_a, children) {
+        var state = _a.state;
+        var creator = index.getRenderingRef();
+        if (multiverse.has(creator)) {
+            var universe = multiverse.get(creator);
+            universe.state = state;
+            universe.wormholes.forEach(function (opening) { updateConsumer(opening, state); });
+        }
+        return children;
+    }
+};
+
+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
+});
+
+const squirrelly_min$1 = /*@__PURE__*/_commonjsHelpers.getDefaultExportFromCjs(squirrelly_min);
+
+const Sqrl = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(null), squirrelly_min, {
+    'default': squirrelly_min$1
+}));
+
+const squirrel = Sqrl;
+squirrel.filters.define('date_long', (str, options = { year: 'numeric', month: 'long', day: 'numeric' }) => {
+  if (!str)
+    return;
+  let date = new Date(parseInt(str) * 1000);
+  str = date.toLocaleDateString('en-GB', options);
+  return str;
+});
+squirrel.filters.define('date_short', (str, format = 'd/m/y') => {
+  if (!str)
+    return;
+  let date = new Date(parseInt(str) * 1000);
+  str = format.replace(/(d)/, date.getDate().toString());
+  str = str.replace(/(m)/, (date.getMonth() + 1).toString());
+  str = str.replace(/(y)/, date.getFullYear().toString());
+  return str;
+});
+squirrel.filters.define('public_name', (str) => {
+  if (!str)
+    return;
+  str = str
+    .split('_')
+    .map((val) => {
+    return val.length < 3 ? val.toUpperCase() : val;
+  })
+    .join(' ');
+  return str.charAt(0).toUpperCase() + str.slice(1);
+});
+squirrel.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) => {
+  if (!str)
+    return;
+  return str.replace(/[\W]+/g, '');
+});
+squirrel.filters.define('abs_url', (str, index = null, result) => {
+  if (!index)
+    return str;
+  if (!str)
+    return;
+  let domain = undefined;
+  if (index.domains && result && result.origin) {
+    let found = index.domains.find((dm) => dm.origin === result.origin);
+    domain = found ? found.domain : '';
+  }
+  else if (index.domain)
+    domain = index.domain;
+  if (!domain)
+    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()));
+const Squirrel = squirrel;
+
+class PromiseQueue {
+  constructor() {
+    this.queue = [];
+    this.workingOnPromise = false;
+    this.stop = false;
+    this.limit = null;
+  }
+  enqueue(promise) {
+    return new Promise((resolve, reject) => {
+      this.queue.push({
+        promise,
+        resolve,
+        reject,
+      });
+      this.dequeue();
+    });
+  }
+  dequeue() {
+    if (this.workingOnPromise) {
+      return false;
+    }
+    if (this.stop) {
+      this.queue = [];
+      this.stop = false;
+      return;
+    }
+    const item = this.queue.shift();
+    if (!item) {
+      return false;
+    }
+    try {
+      this.workingOnPromise = true;
+      item
+        .promise()
+        .then((value) => {
+        this.workingOnPromise = false;
+        item.resolve(value);
+        this.dequeue();
+      })
+        .catch((err) => {
+        this.workingOnPromise = false;
+        item.reject(err);
+        this.dequeue();
+      });
+    }
+    catch (err) {
+      this.workingOnPromise = false;
+      item.reject(err);
+      this.dequeue();
+    }
+    return true;
+  }
+}
+PromiseQueue.pendingPromise = false;
+
+const algoliaCss = ":host{-webkit-box-sizing:border-box;box-sizing:border-box}*,*::before,*::after{-webkit-box-sizing:border-box;box-sizing:border-box}:host{position:relative;display:block}:host ::slotted([slot=search-template]),:host::slotted([slot=search-template]){display:none !important}.loader{opacity:0;position:fixed;height:100%;width:100%;min-height:100%;max-height:100vh !important;max-width:100vw !important;left:0;top:0;z-index:-10;font-size:60px;display:-webkit-box;display:-ms-flexbox;display:flex;-webkit-box-align:center;-ms-flex-align:center;align-items:center;-webkit-box-pack:center;-ms-flex-pack:center;justify-content:center;-webkit-transition:opacity 0.2s ease, z-index 0.01s ease 0.2s;transition:opacity 0.2s ease, z-index 0.01s ease 0.2s}.loader.loading{opacity:1;z-index:10;-webkit-transition:z-index 0.01s ease, opacity 0.2s ease 0.01s;transition:z-index 0.01s ease, opacity 0.2s ease 0.01s}.default{height:100%}.default:focus{outline:none}.results{opacity:0;outline:none;overflow:auto;-webkit-transition:opacity 0.3s ease, visibility 0.01s ease 0.3s, z-index 0.01s ease 0.3s, -webkit-transform 0.3s ease;transition:opacity 0.3s ease, visibility 0.01s ease 0.3s, z-index 0.01s ease 0.3s, -webkit-transform 0.3s ease;transition:transform 0.3s ease, opacity 0.3s ease, visibility 0.01s ease 0.3s, z-index 0.01s ease 0.3s;transition:transform 0.3s ease, opacity 0.3s ease, visibility 0.01s ease 0.3s, z-index 0.01s ease 0.3s, -webkit-transform 0.3s ease;-webkit-transform:translate(0, 100px);transform:translate(0, 100px);visibility:hidden;z-index:-1;position:absolute;top:0;left:0;display:none}.results-container{position:relative}.results.show{-webkit-transition:z-index 0.01s ease, visibility 0.01s ease, opacity 0.3s ease 0.01s, -webkit-transform 0.3s ease 0.01s;transition:z-index 0.01s ease, visibility 0.01s ease, opacity 0.3s ease 0.01s, -webkit-transform 0.3s ease 0.01s;transition:z-index 0.01s ease, visibility 0.01s ease, transform 0.3s ease 0.01s, opacity 0.3s ease 0.01s;transition:z-index 0.01s ease, visibility 0.01s ease, transform 0.3s ease 0.01s, opacity 0.3s ease 0.01s, -webkit-transform 0.3s ease 0.01s;-webkit-transform:translate(0, 0);transform:translate(0, 0);visibility:visible;opacity:1;z-index:10;overflow:hidden}.results.shown{height:auto !important;width:auto !important;display:block;position:static;-webkit-transform:none;transform:none;z-index:auto;visibility:inherit;opacity:initial}";
+
+const CANSHADOW = !!document.head.attachShadow;
+let Algolia = class {
+  constructor(hostRef) {
+    index.registerInstance(this, hostRef);
+    this.nanoDidLoad = index.createEvent(this, "nanoDidLoad", 7);
+    this.nanoResultsShown = index.createEvent(this, "nanoResultsShown", 3);
+    this.nanoBeforeQuery = index.createEvent(this, "nanoBeforeQuery", 7);
+    this.nanoAfterQuery = index.createEvent(this, "nanoAfterQuery", 7);
+    // filters that have an initial value
+    this.staticFacetFilters = {};
+    this.dynFacetFilters = {};
+    this.hasLoadSlot = false;
+    this.placedAlgoliaEles = [];
+    // lots of stuff happens asynchronously. This makes sure they fire in the corrent order
+    this.promiseQueue = new PromiseQueue();
+    // Internal state
+    // filters that change via a template. They have no initial value
+    this._dynFacetFilters = {};
+    this.indeces = [];
+    this.filterChanged = '';
+    this.changeEvent = algoliaData.SearchChangeEvent.Init;
+    this.isLoading = false;
+    this.wormholeState = this;
+    // Public props
+    /**
+     * Show the result panel. By default it will automatically show when the result receives new hits.
+     */
+    this.showResults = false;
+    /**
+     * The current algolia page of results currently being viewed or to get.
+     */
+    this.resultsPage = 0;
+    /**
+     * Algolia search index. Used in conjunction with 'apiKey' & 'appId'.
+     * ```
+     * { index: string, // algolia index name
+     *   domain?: string, // used in template filters to resolve incomplete url fields
+     *   filters?: [string], // algolia facets to retrive
+     *   hitsPerPage?: number,
+     *   name?: string // human readable index name
+     * }
+     * ```
+     */
+    this.searchIndex = {};
+    /**
+     * Algolia search index name. Alternative to 'searchIndex'.
+     * A simplified shortcut for setting an index.
+     * Properties such as hitsPerPage and facets will come from the algolia index
+     */
+    this.searchIndexName = '';
+    /**
+     * JS querSelector string of a `nano-input` / `input` element from which
+     * to listen to `nano-change` or `change` events and change the `query` prop.
+     * Not required if an appropriate field is in the 'search-input' slot
+     */
+    this.listenTo = null;
+    /**
+     * The query string used to search the index. Will automtically be set with any slotted
+     * `search-input` input elements or from elements linked to from `listen-to`
+     */
+    this.query = '';
+    /**
+     * The external operator joining filter values.
+     */
+    this.operator = 'and';
+    /**
+     * Query filters to apply to all searches.
+     * Refer to https://www.algolia.com/doc/api-reference/api-parameters/filters for format.
+     */
+    this.filters = [];
+    /**
+     * Template engine to use when rendering results and filters.
+     * Defaults to Squirrel v8 (https://squirrelly.js.org/). This gives you access
+     * to the underlying squirrel object allowing you to modify it's configuration / add filters.
+     */
+    this.tplEngine = Squirrel;
+    /**
+     * Template engine render function to use when rendering results and filters.
+     * Defaults to Squirrel v8's render (https://squirrelly.js.org/).
+     */
+    this.tplRenderFn = Squirrel.render;
+    /**
+     * Changes the index without removing any current filters. Most appropriate for algolia replicas.
+     */
+    this.replicaIndex = '';
+    /**
+     * Will maintain a search all / '*' on init and reset allowing for a view
+     * then filter experience rather than a search first experience
+     */
+    this.browseIndex = false;
+    /**
+     * Minimum number of characters before performing a search
+     */
+    this.minChars = 2;
+    /**
+     * The method of storage.
+     * Either session storage, url hash (after the '#') or url query (after the '?').
+     */
+    this.storeMethod = 'session';
+    this.searchChange = async () => {
+      if (!this.algoliaIndex)
+        return;
+      if (!this.query || this.query.length < this.minChars) {
+        if (!this.browseIndex) {
+          if (!this.query || this.query.length === 0) {
+            this.handleSearchReset();
+            return;
+          }
+          else
+            return;
+        }
+        else if (this.query !== '*') {
+          this.query = '*';
+          return;
+        }
+      }
+      // Do an initialise search (setup searchIndex)
+      this.isLoading = true;
+      setTimeout(async () => {
+        // Clear dynamic filters and reset page
+        this.resetPage();
+        await this.algoliaSearch(algoliaData.SearchChangeEvent.Init);
+        // Populate master content - optionally from template
+        await this.updateContent();
+        setTimeout((_) => (this.isLoading = false), 800);
+        this.showResults = true;
+        this.nanoResultsShown.emit(this.indexResults);
+      }, 200);
+    };
+    // Takes all current filters (dynamic and static)
+    // and merges common filters' values togther
+    this.makeAppliedFilters = () => {
+      let appliedFtrs = [];
+      const makeAppliedFilter = (facetFilters) => {
+        Object.values(facetFilters).forEach((filter) => {
+          if (filter.value && filter.value.length) {
+            let found = appliedFtrs.find((appFilter) => appFilter.name === filter.facetName);
+            if (!found)
+              appliedFtrs.push({
+                name: filter.facetName,
+                values: [...filter.value],
+              });
+            else
+              found.values = [...found.values, ...filter.value];
+          }
+        });
+      };
+      makeAppliedFilter(this.dynFacetFilters);
+      makeAppliedFilter(this.staticFacetFilters);
+      if (appliedFtrs.length)
+        return appliedFtrs;
+      return null;
+    };
+    // Queue up a search
+    this.algoliaSearch = async (eventType) => {
+      return this.promiseQueue.enqueue(() => this.queueSearch(eventType));
+    };
+    // Do a search
+    this.queueSearch = async (eventType) => {
+      if (!this.algoliaIndex ||
+        !this.query ||
+        !this.searchIndex ||
+        !this.searchIndex.index)
+        return;
+      this.nanoBeforeQuery.emit(this.indexResults);
+      // clear all facet filters on init (new query)
+      if (algoliaData.SearchChangeEvent.Init === eventType)
+        this.clearAllFacetFilters();
+      let searchParams = {
+        filters: this.algoliaFilterStr(),
+        page: this.indexResults ? this.indexResults.currentPage : 0,
+      };
+      if (this.searchIndex.filters)
+        searchParams.facets = this.searchIndex.filters;
+      if (this.searchIndex.hitsPerPage)
+        searchParams.hitsPerPage = this.searchIndex.hitsPerPage;
+      let result = (await this.algoliaIndex.search(this.query, searchParams));
+      result = this.fixDomain(result);
+      // set event type - this informs children components why things changed
+      this.changeEvent = eventType;
+      // Setup initial meta on new queries. Some of it should not change on filter / pagination
+      if (eventType === algoliaData.SearchChangeEvent.Init || !this.indexResults) {
+        this.indexResults = {
+          currentPage: 0,
+          totalHits: result.nbHits,
+          hitsPerPage: null,
+          origFilters: result.facets,
+          query: this.query,
+          domain: this.searchIndex.domain || null,
+          legacy: !CANSHADOW,
+          totalHitsWithFilters: 0,
+          results: [],
+          totalPages: 0,
+          appliedFilters: this.makeAppliedFilters(),
+          indexName: this.searchIndex.name || null,
+          index: this.searchIndex.index,
+        };
+      }
+      this.indexResults.dynFilters = result.facets;
+      this.indexResults.results = result.hits;
+      this.indexResults.totalHitsWithFilters = result.nbHits;
+      this.indexResults.currentPage = result.page;
+      this.indexResults.totalPages = result.nbPages;
+      this.indexResults.hitsPerPage = result.hitsPerPage;
+      this.indexResults.query = result.query;
+      // console.log('I GOT NEW RESULTS', eventType, this.query, this.algoliaFilterStr(), this.indexResults.results.length, this.indexResults.currentPage )
+      if (this.changeEvent !== algoliaData.SearchChangeEvent.Page &&
+        this.changeEvent !== algoliaData.SearchChangeEvent.Replica) {
+        this.facets = result.facets;
+      }
+      this.nanoAfterQuery.emit(this.indexResults);
+      // current hits and page will cause re-renders in children components.
+      // Wait a tick before firing otherwise events can fire in the wrong order
+      return new Promise((resolve) => {
+        setTimeout(() => resolve('tpl updated'), 20);
+      }).then((_) => {
+        this.currentHits = this.indexResults.results;
+        this.resultsPage = this.indexResults.currentPage;
+      });
+    };
+    this.handleInputChange = (ev) => {
+      if (ev.target !== this.inputField)
+        return;
+      this.query = this.inputField.value;
+    };
+    this.handleSearchReset = () => {
+      this.showResults = false;
+      this.indexResults = null;
+    };
+    this.onResultDisplay = () => {
+      index.writeTask(() => {
+        this.resultsDiv.removeEventListener('transitionend', this.onResultDisplay);
+        if (!this.showResults)
+          this.resultsDiv.style.display = 'none';
+        else {
+          this.defaultDiv.style.display = 'none';
+          this.resultsDiv.classList.add('shown');
+          this.resultsDiv.style.minHeight = '';
+          this.resultsDiv.style.width = '';
+        }
+      });
+    };
+  }
+  // Public methods
+  /**
+   * @param facetName - will clear all filter selections of that type
+   * @param facetValue - will remove a single filter selection
+   * Remove facet filters (as set from nano-algolia-filter elements).
+   * The omission or both will remove all facet filters
+   */
+  async removeFilters(facetName, facetValue) {
+    if (!facetName && !facetValue)
+      this.clearAllFacetFilters();
+    else {
+      Object.keys(this._dynFacetFilters).forEach((filterId) => {
+        if (facetName &&
+          this._dynFacetFilters[filterId].facetName === facetName) {
+          if (!facetValue)
+            this._dynFacetFilters[filterId].element.value = '';
+          else {
+            this._dynFacetFilters[filterId].element.value =
+              this._dynFacetFilters[filterId].value.filter((val) => val !== facetValue);
+          }
+        }
+      });
+    }
+  }
+  // Listeners to external events
+  // a child nano-algolia-... updated their template
+  onAllTplUpdate(ev) {
+    ev.stopPropagation();
+  }
+  // a nano-algolia-pagination or nano-algolia-results changed the page
+  async onPageChange(ev) {
+    if (!this.indexResults)
+      return;
+    let page = this.resultsPage;
+    if (ev) {
+      ev.stopPropagation();
+      page = ev.detail.page;
+    }
+    page = Math.min(this.indexResults.totalPages - 1, page);
+    page = Math.max(page, 0);
+    if (this.indexResults.currentPage === page)
+      return;
+    this.indexResults.currentPage = page;
+    await this.algoliaSearch(algoliaData.SearchChangeEvent.Page);
+  }
+  /**
+   * nano-algolia-filter changed value.
+   * If that happened before a indexResults were setup, it was a static filter.
+   * Static filters persist accross search changes
+   */
+  async onFilterChange(ev) {
+    ev.stopPropagation();
+    let dynFilterObj = {};
+    let filter = ev.detail;
+    filter.element = ev.target;
+    if (this.indexResults) {
+      if (this.staticFacetFilters[filter.filterId])
+        this.staticFacetFilters[filter.filterId] = filter;
+      else {
+        dynFilterObj[filter.filterId] = filter;
+        this._dynFacetFilters = Object.assign(Object.assign({}, this._dynFacetFilters), dynFilterObj);
+      }
+      this.indexResults.appliedFilters = this.makeAppliedFilters();
+    }
+    else
+      this.staticFacetFilters[filter.filterId] = filter;
+    this.filterChanged =
+      filter.value && filter.value.length ? filter.filterId : 'all';
+    this.resetPage();
+    this.algoliaSearch(algoliaData.SearchChangeEvent.Filter);
+  }
+  // Internal state watchers
+  // Filters can fire a change event, cause a re-render then get detached.
+  // This can cause filter dupes. Check to see if the original element is still in the DOM.
+  dynFacetFiltersChange() {
+    Object.values(this._dynFacetFilters).forEach((filter) => {
+      if (this.host.ownerDocument === filter.element.ownerDocument)
+        this.dynFacetFilters[filter.filterId] = filter;
+      else
+        delete this.dynFacetFilters[filter.filterId];
+    });
+  }
+  browseIndexChange() {
+    if (this.browseIndex &&
+      (!this.query || this.query.length < this.minChars)) {
+      this.query = '*';
+    }
+  }
+  inputFieldSet() {
+    if (!this.inputField)
+      return;
+    if (this.query !== '*' &&
+      this.inputField &&
+      this.inputField.value !== this.query)
+      this.inputField.value = this.query;
+  }
+  queryChange() {
+    this.searchChange();
+  }
+  async internalIndexSwitch() {
+    if (!this.replicaIndex ||
+      !this.indexResults ||
+      this.indexResults.index === this.replicaIndex)
+      return;
+    this.indexResults.index = this.replicaIndex;
+    this.algoliaIndex = this.algoliaClient.initIndex(this.indexResults.index);
+    this.resetPage();
+    this.algoliaSearch(algoliaData.SearchChangeEvent.Replica);
+  }
+  pageChange() {
+    this.onPageChange();
+  }
+  searchIndexNameChange() {
+    if (!this.searchIndexName ||
+      !this.searchIndexName.length ||
+      (this.searchIndex && this.searchIndex.index === this.searchIndexName))
+      return;
+    this.searchIndex = { index: this.searchIndexName };
+  }
+  initAlgoliaClient() {
+    if (!this.appId || !this.apiKey)
+      return;
+    this.algoliaClient = algoliasearch_umd.algoliasearch_umd(this.appId, this.apiKey);
+  }
+  initAlgoliaIndex() {
+    if (!this.algoliaClient || !this.searchIndex)
+      return;
+    if (this.searchIndex.index) {
+      if (this.replicaIndex)
+        this.searchIndex.index = this.replicaIndex;
+      this.searchIndexName = this.searchIndex.index;
+      this.algoliaIndex = this.algoliaClient.initIndex(this.searchIndex.index);
+      this.searchChange();
+    }
+  }
+  newListenTo() {
+    if (!this.listenTo)
+      this.attachInputListener(false);
+    else {
+      setTimeout(() => {
+        this.inputField = document.querySelector(this.listenTo);
+        if (this.inputField)
+          this.attachInputListener(true);
+      }, 50);
+    }
+  }
+  showResultsChange() {
+    if (!this.resultsDiv || !this.defaultDiv)
+      return;
+    if (this.showResults) {
+      this.resultsDiv.style.width = this.host.scrollWidth + 'px';
+      this.resultsDiv.style.minHeight = this.host.scrollHeight + 'px';
+      index.writeTask(() => {
+        this.resultsDiv.addEventListener('transitionend', this.onResultDisplay);
+        this.resultsDiv.style.display = 'block';
+        setTimeout(() => this.resultsDiv.classList.add('show'), 50);
+      });
+    }
+    else {
+      index.writeTask(() => {
+        this.resultsDiv.classList.remove('shown');
+        this.defaultDiv.style.display = 'block';
+        setTimeout(() => {
+          this.resultsDiv.addEventListener('transitionend', this.onResultDisplay);
+          this.resultsDiv.classList.remove('show');
+          if (!!this.slottedInput)
+            this.slottedInput.focus({ preventScroll: true });
+          else
+            this.defaultDiv.focus({ preventScroll: true });
+        }, 50);
+      });
+    }
+  }
+  // Internal methods
+  fixDomain(results) {
+    if (!this.searchIndex || !this.searchIndex.domain)
+      return results;
+    results.hits.map((hit) => {
+      if (hit.url && !hit.url.match(/^http/))
+        hit.url = location.protocol + '//' + this.searchIndex.domain + hit.url;
+    });
+    return results;
+  }
+  resetPage() {
+    if (!this.indexResults)
+      return;
+    this.indexResults.currentPage = 0;
+  }
+  clearAllFacetFilters() {
+    Object.values(this._dynFacetFilters).forEach((filter) => {
+      filter.element.value = '';
+    });
+    this._dynFacetFilters = {};
+  }
+  algoliaFilterStr() {
+    // groups applied facet filters (from algolia-filter components)
+    // with their applied, 'internal' operators (and, or, not)
+    let facetFilterObj = {};
+    const groupFilters = (facetFilters) => {
+      let filter;
+      let filterOp;
+      Object.keys(facetFilters).forEach((filterId) => {
+        filter = facetFilters[filterId];
+        facetFilterObj[filterId] = facetFilterObj[filterId] || {
+          name: filter.facetName,
+          or: [],
+          and: [],
+          not: [],
+        };
+        filterOp = facetFilterObj[filterId][filter.operator];
+        if (filter.value && filter.value.length) {
+          facetFilterObj[filterId][filter.operator] = [
+            ...filterOp,
+            ...filter.value,
+          ];
+        }
+      });
+    };
+    groupFilters(this.dynFacetFilters);
+    groupFilters(this.staticFacetFilters);
+    const formatVal = (name, val) => {
+      if (val.indexOf(' ') > -1)
+        return name + ':"' + val + '"';
+      else
+        return name + ':' + val;
+    };
+    let filterStrParts = [];
+    let operatorGrp;
+    let filterName;
+    // let processedFilters: string[] = [];
+    // joins all applied facet filter operator groups with the set 'outer'
+    // operator into an algolia filter query string
+    Object.values(facetFilterObj).forEach(function (filter) {
+      Object.keys(filter)
+        .filter((filterProp) => filterProp.match(/(or|and|not)/))
+        .forEach((operator) => {
+        operatorGrp = filter;
+        filterName = filter.name;
+        if (operator === 'or' || operator === 'and') {
+          if (operatorGrp[operator].length) {
+            filterStrParts.push('( \
+                ' +
+              operatorGrp[operator]
+                .map((val) => {
+                if (val.length)
+                  return formatVal(filterName, val);
+              })
+                .join(' ' + operator.toLocaleUpperCase() + ' ') +
+              ' \
+              )');
+          }
+        }
+        else {
+          if (operatorGrp.not.length) {
+            filterStrParts.push('( \
+                ' +
+              operatorGrp[operator]
+                .map((val) => {
+                if (val.length)
+                  return 'NOT ' + formatVal(filterName, val);
+              })
+                .join(' AND ') +
+              ' \
+              )');
+          }
+        }
+      });
+    });
+    // add in any static applied filters from filters prop
+    filterStrParts = [...this.filters, ...filterStrParts];
+    // console.log('filterStr:', filterStrParts.join(' ' + this.operator.toLocaleUpperCase() + ' '))
+    return filterStrParts.join(' ' + this.operator.toLocaleUpperCase() + ' ');
+  }
+  attachInputListener(setup = true) {
+    if (!this.inputField)
+      return;
+    let eventName = this.inputField.tagName.toLocaleLowerCase() === 'nano-input'
+      ? 'nanoChange'
+      : 'change';
+    if (setup)
+      this.inputField.addEventListener(eventName, this.handleInputChange);
+    else
+      this.inputField.removeEventListener(eventName, this.handleInputChange);
+  }
+  async updateContent() {
+    return this.promiseQueue.enqueue(() => this.updateContentQueue());
+  }
+  async updateContentQueue() {
+    let outputTo = this.outputSlot || this.resultsDiv;
+    if (!outputTo || !this.tpl)
+      return 'no tpl';
+    let tmpCont = document.createElement('div');
+    tmpCont.innerHTML = this.tpl;
+    let algoliaEles = [];
+    this.placedAlgoliaEles = [];
+    // take out children algolia elements 'cos they have their own templates
+    // don't want to swap in their templates
+    Array.from(tmpCont.querySelectorAll('nano-algolia, nano-algolia-filter, nano-algolia-results')).forEach((el, i) => {
+      let placeholder = document.createElement('div');
+      placeholder.dataset.placeholderId = i.toString();
+      placeholder.classList.add('nano-ele-placeholder');
+      algoliaEles.push(el);
+      el.parentNode.replaceChild(placeholder, el);
+    });
+    // swap in template content
+    // (all this nonsense htmlencodes any < or >)
+    outputTo.innerHTML = this.tplRenderFn(tmpCont.innerHTML
+      .replace(/&gt;/gm, '>')
+      .replace(/&lt;/gm, '<')
+      .replace(/&amp;/gm, '&'), this.indexResults);
+    // put back in algolia elements
+    Array.from(outputTo.querySelectorAll('div.nano-ele-placeholder')).forEach((el) => {
+      el.parentNode.replaceChild(algoliaEles[parseInt(el.dataset.placeholderId)], el);
+      this.placedAlgoliaEles.push(algoliaEles[parseInt(el.dataset.placeholderId)]);
+    });
+    if (!this.placedAlgoliaEles.length)
+      return Promise.resolve('algolia setup');
+    // wait for all children algolia elements to resolve before calling 'done'
+    return new Promise((resolve) => {
+      const childrenResolver = (ev) => {
+        this.placedAlgoliaEles = this.placedAlgoliaEles.filter((ele) => ele !== ev.detail);
+        if (!this.placedAlgoliaEles.length) {
+          setTimeout(() => resolve('tpl updated'), 500);
+          outputTo.removeEventListener('nanoTplUpdated', childrenResolver);
+        }
+      };
+      outputTo.addEventListener('nanoTplUpdated', childrenResolver);
+    });
+  }
+  // Stencil hooks
+  componentWillLoad() {
+    index.readTask((_) => {
+      this.tplSlot = dom.getDirectChildren(this.host, '[slot="template"]')[0];
+      this.outputSlot = dom.getDirectChildren(this.host, '[slot="output"]')[0];
+      this.slottedInput = dom.getDirectChildren(this.host, '[slot="search-input"]')[0];
+      this.hasLoadSlot = !!dom.getDirectChildren(this.host, '[slot="loader"]')[0];
+      if (!!this.tplSlot)
+        this.tpl = this.tplSlot.innerHTML;
+      // get input field to listen to
+      if (this.slottedInput &&
+        (this.slottedInput.tagName.toLocaleLowerCase() === 'nano-input' ||
+          this.slottedInput instanceof HTMLInputElement)) {
+        this.inputField = this.slottedInput;
+      }
+      else if (this.slottedInput) {
+        this.inputField = this.slottedInput.querySelector('nano-input, input:not([type="radio"]):not([type="checkbox"])');
+      }
+      if (!this.inputField && this.listenTo)
+        this.inputField = document.querySelector(this.listenTo);
+      if (this.inputField)
+        this.attachInputListener(true);
+      index.writeTask((_) => {
+        if (this.showResults && this.tpl)
+          this.searchChange();
+      });
+    });
+    this.searchIndexNameChange();
+    this.initAlgoliaClient();
+    this.initAlgoliaIndex();
+    // Create wormwhole shared 'universe' (https://github.com/mihar-22/stencil-wormhole)
+    Universe.create(this, this.wormholeState);
+    if (this.storeId) {
+      componentStore.ComponentStore.init(this, ['query', 'replicaIndex'], this.storeMethod, this.storeId);
+      componentStore.ComponentStore.init(this, ['apiKey', 'appId', 'searchIndex'], 'session', this.storeId + '_api');
+    }
+    this.internalIndexSwitch();
+  }
+  connectedCallback() {
+    this.searchChange = throttle.debounce(this.searchChange, 300);
+    this.browseIndexChange();
+    this.host.dispatchEvent(new CustomEvent('nanoDidLoad', {
+      detail: this.host,
+    }));
+  }
+  render() {
+    const wormholeState = {
+      indexResults: this.indexResults,
+      results: this.currentHits,
+      filterChanged: this.filterChanged,
+      tplRenderFn: this.tplRenderFn,
+      resultsPage: this.resultsPage,
+      changeEvent: this.changeEvent,
+      facets: this.facets,
+      algoliaIndex: this.algoliaIndex,
+      searchIndex: this.searchIndex,
+      globalStoreMethod: this.storeMethod,
+      isLoading: this.isLoading,
+    };
+    return (index.h(index.Host, { class: {
+        'show-results': this.showResults,
+        'is-loading': this.isLoading,
+      }, "aria-busy": this.isLoading }, this.hasLoadSlot && (index.h("div", { hidden: !this.isLoading }, index.h("slot", { name: "loader" }))), !this.hasLoadSlot && (index.h("div", { class: {
+        loader: true,
+        loading: this.isLoading,
+      } }, index.h("nano-spinner", { overlay: true, type: "circle" }))), index.h(Universe.Provider, { state: wormholeState }, index.h("slot", { name: "search-input" }), index.h("div", { class: "results-container", "aria-live": "polite" }, index.h("div", { ref: (div) => (this.resultsDiv = div), class: "results" }, index.h("slot", { name: "output" })))), index.h("div", { ref: (div) => (this.defaultDiv = div), class: "default", tabindex: "-1" }, index.h("slot", null))));
+  }
+  get host() { return index.getElement(this); }
+  static get watchers() { return {
+    "_dynFacetFilters": ["dynFacetFiltersChange"],
+    "browseIndex": ["browseIndexChange"],
+    "inputField": ["inputFieldSet"],
+    "query": ["queryChange"],
+    "replicaIndex": ["internalIndexSwitch"],
+    "resultsPage": ["pageChange"],
+    "searchIndexName": ["searchIndexNameChange"],
+    "apiKey": ["initAlgoliaClient"],
+    "appId": ["initAlgoliaClient"],
+    "searchIndex": ["initAlgoliaIndex"],
+    "listenTo": ["newListenTo"],
+    "showResults": ["showResultsChange"]
+  }; }
+};
+Algolia.style = algoliaCss;
+
+exports.nano_algolia = Algolia;
+
+//# sourceMappingURL=nano-algolia.cjs.entry.js.map