@startinblox/core 0.19.0-beta.2 → 0.19.0-beta.21

package/dist/{_snowpack/pkg/fusejs.js → assets/helpers-411e08e4.js}

@@ -1,82 +1,84 @@
-/**
- * Fuse.js v6.6.2 - Lightweight fuzzy-search (http://fusejs.io)
- *
- * Copyright (c) 2022 Kiro Risk (http://kiro.me)
- * All Rights Reserved. Apache Software License 2.0
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- */
-
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+var _values, _resolve, _createIterable, createIterable_fn, _next, next_fn, _nextPromise, nextPromise_fn;
 function isArray(value) {
-  return !Array.isArray ? getTag(value) === '[object Array]' : Array.isArray(value);
+  return !Array.isArray ? getTag(value) === "[object Array]" : Array.isArray(value);
 }
-
-// Adapted from: https://github.com/lodash/lodash/blob/master/.internal/baseToString.js
 const INFINITY = 1 / 0;
 function baseToString(value) {
-  // Exit early for strings to avoid a performance hit in some environments.
-  if (typeof value == 'string') {
+  if (typeof value == "string") {
     return value;
   }
-  let result = value + '';
-  return result == '0' && 1 / value == -INFINITY ? '-0' : result;
+  let result = value + "";
+  return result == "0" && 1 / value == -INFINITY ? "-0" : result;
 }
 function toString(value) {
-  return value == null ? '' : baseToString(value);
+  return value == null ? "" : baseToString(value);
 }
 function isString(value) {
-  return typeof value === 'string';
+  return typeof value === "string";
 }
 function isNumber(value) {
-  return typeof value === 'number';
+  return typeof value === "number";
 }
-
-// Adapted from: https://github.com/lodash/lodash/blob/master/isBoolean.js
 function isBoolean(value) {
-  return value === true || value === false || isObjectLike(value) && getTag(value) == '[object Boolean]';
+  return value === true || value === false || isObjectLike(value) && getTag(value) == "[object Boolean]";
 }
 function isObject(value) {
-  return typeof value === 'object';
+  return typeof value === "object";
 }
-
-// Checks if `value` is object-like.
 function isObjectLike(value) {
   return isObject(value) && value !== null;
 }
 function isDefined(value) {
-  return value !== undefined && value !== null;
+  return value !== void 0 && value !== null;
 }
 function isBlank(value) {
   return !value.trim().length;
 }
-
-// Gets the `toStringTag` of `value`.
-// Adapted from: https://github.com/lodash/lodash/blob/master/.internal/getTag.js
 function getTag(value) {
-  return value == null ? value === undefined ? '[object Undefined]' : '[object Null]' : Object.prototype.toString.call(value);
+  return value == null ? value === void 0 ? "[object Undefined]" : "[object Null]" : Object.prototype.toString.call(value);
 }
-const EXTENDED_SEARCH_UNAVAILABLE = 'Extended search is not available';
+const EXTENDED_SEARCH_UNAVAILABLE = "Extended search is not available";
 const INCORRECT_INDEX_TYPE = "Incorrect 'index' type";
-const LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY = key => `Invalid value for key ${key}`;
-const PATTERN_LENGTH_TOO_LARGE = max => `Pattern length exceeds max of ${max}.`;
-const MISSING_KEY_PROPERTY = name => `Missing ${name} property in key`;
-const INVALID_KEY_WEIGHT_VALUE = key => `Property 'weight' in key '${key}' must be a positive integer`;
+const LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY = (key) => `Invalid value for key ${key}`;
+const PATTERN_LENGTH_TOO_LARGE = (max) => `Pattern length exceeds max of ${max}.`;
+const MISSING_KEY_PROPERTY = (name) => `Missing ${name} property in key`;
+const INVALID_KEY_WEIGHT_VALUE = (key) => `Property 'weight' in key '${key}' must be a positive integer`;
 const hasOwn = Object.prototype.hasOwnProperty;
 class KeyStore {
   constructor(keys) {
     this._keys = [];
     this._keyMap = {};
     let totalWeight = 0;
-    keys.forEach(key => {
+    keys.forEach((key) => {
       let obj = createKey(key);
       totalWeight += obj.weight;
       this._keys.push(obj);
       this._keyMap[obj.id] = obj;
       totalWeight += obj.weight;
     });
-
-    // Normalize weights so that their sum is equal to 1
-    this._keys.forEach(key => {
+    this._keys.forEach((key) => {
       key.weight /= totalWeight;
     });
   }
@@ -101,12 +103,12 @@ function createKey(key) {
     path = createKeyPath(key);
     id = createKeyId(key);
   } else {
-    if (!hasOwn.call(key, 'name')) {
-      throw new Error(MISSING_KEY_PROPERTY('name'));
+    if (!hasOwn.call(key, "name")) {
+      throw new Error(MISSING_KEY_PROPERTY("name"));
     }
     const name = key.name;
     src = name;
-    if (hasOwn.call(key, 'weight')) {
+    if (hasOwn.call(key, "weight")) {
       weight = key.weight;
       if (weight <= 0) {
         throw new Error(INVALID_KEY_WEIGHT_VALUE(name));
@@ -116,56 +118,42 @@ function createKey(key) {
     id = createKeyId(name);
     getFn = key.getFn;
   }
-  return {
-    path,
-    id,
-    weight,
-    src,
-    getFn
-  };
+  return { path, id, weight, src, getFn };
 }
 function createKeyPath(key) {
-  return isArray(key) ? key : key.split('.');
+  return isArray(key) ? key : key.split(".");
 }
 function createKeyId(key) {
-  return isArray(key) ? key.join('.') : key;
+  return isArray(key) ? key.join(".") : key;
 }
 function get(obj, path) {
   let list = [];
   let arr = false;
-  const deepGet = (obj, path, index) => {
-    if (!isDefined(obj)) {
+  const deepGet = (obj2, path2, index) => {
+    if (!isDefined(obj2)) {
       return;
     }
-    if (!path[index]) {
-      // If there's no path left, we've arrived at the object we care about.
-      list.push(obj);
+    if (!path2[index]) {
+      list.push(obj2);
     } else {
-      let key = path[index];
-      const value = obj[key];
+      let key = path2[index];
+      const value = obj2[key];
       if (!isDefined(value)) {
         return;
       }
-
-      // If we're at the last value in the path, and if it's a string/number/bool,
-      // add it to the list
-      if (index === path.length - 1 && (isString(value) || isNumber(value) || isBoolean(value))) {
+      if (index === path2.length - 1 && (isString(value) || isNumber(value) || isBoolean(value))) {
         list.push(toString(value));
       } else if (isArray(value)) {
         arr = true;
-        // Search each item in the array.
         for (let i = 0, len = value.length; i < len; i += 1) {
-          deepGet(value[i], path, index + 1);
+          deepGet(value[i], path2, index + 1);
         }
-      } else if (path.length) {
-        // An object. Recurse further.
-        deepGet(value, path, index + 1);
+      } else if (path2.length) {
+        deepGet(value, path2, index + 1);
       }
     }
   };
-
-  // Backwards compatibility (since path used to be a string)
-  deepGet(obj, isString(path) ? path.split('.') : path, 0);
+  deepGet(obj, isString(path) ? path.split(".") : path, 0);
   return arr ? list : list[0];
 }
 const MatchOptions = {
@@ -229,11 +217,8 @@ var Config = {
   ...AdvancedOptions
 };
 const SPACE = /[^ ]+/g;
-
-// Field-length norm: the shorter the field, the higher the weight.
-// Set to 3 decimals to reduce index size.
 function norm(weight = 1, mantissa = 3) {
-  const cache = new Map();
+  const cache = /* @__PURE__ */ new Map();
   const m = Math.pow(10, mantissa);
   return {
     get(value) {
@@ -241,12 +226,8 @@ function norm(weight = 1, mantissa = 3) {
       if (cache.has(numTokens)) {
         return cache.get(numTokens);
       }
-
-      // Default function is 1/sqrt(x), weight makes that variable
-      const norm = 1 / Math.pow(numTokens, 0.5 * weight);
-
-      // In place of `toFixed(mantissa)`, for faster computation
-      const n = parseFloat(Math.round(norm * m) / m);
+      const norm2 = 1 / Math.pow(numTokens, 0.5 * weight);
+      const n = parseFloat(Math.round(norm2 * m) / m);
       cache.set(numTokens, n);
       return n;
     },
@@ -283,14 +264,11 @@ class FuseIndex {
       return;
     }
     this.isCreated = true;
-
-    // List is Array<String>
     if (isString(this.docs[0])) {
       this.docs.forEach((doc, docIndex) => {
         this._addString(doc, docIndex);
       });
     } else {
-      // List is Array<Object>
       this.docs.forEach((doc, docIndex) => {
         this._addObject(doc, docIndex);
       });
@@ -309,8 +287,6 @@ class FuseIndex {
   // Removes the doc at the specified index of the index
   removeAt(idx) {
     this.records.splice(idx, 1);
-
-    // Change ref index of every subsquent doc
     for (let i = idx, len = this.size(); i < len; i += 1) {
       this.records[i].i -= 1;
     }
@@ -333,12 +309,7 @@ class FuseIndex {
     this.records.push(record);
   }
   _addObject(doc, docIndex) {
-    let record = {
-      i: docIndex,
-      $: {}
-    };
-
-    // Iterate over every key (i.e, path), and fetch the value at that key
+    let record = { i: docIndex, $: {} };
     this.keys.forEach((key, keyIndex) => {
       let value = key.getFn ? key.getFn(doc) : this.getFn(doc, key.path);
       if (!isDefined(value)) {
@@ -346,33 +317,28 @@ class FuseIndex {
       }
       if (isArray(value)) {
         let subRecords = [];
-        const stack = [{
-          nestedArrIndex: -1,
-          value
-        }];
+        const stack = [{ nestedArrIndex: -1, value }];
         while (stack.length) {
-          const {
-            nestedArrIndex,
-            value
-          } = stack.pop();
-          if (!isDefined(value)) {
+          const { nestedArrIndex, value: value2 } = stack.pop();
+          if (!isDefined(value2)) {
             continue;
           }
-          if (isString(value) && !isBlank(value)) {
+          if (isString(value2) && !isBlank(value2)) {
             let subRecord = {
-              v: value,
+              v: value2,
               i: nestedArrIndex,
-              n: this.norm.get(value)
+              n: this.norm.get(value2)
             };
             subRecords.push(subRecord);
-          } else if (isArray(value)) {
-            value.forEach((item, k) => {
+          } else if (isArray(value2)) {
+            value2.forEach((item, k) => {
               stack.push({
                 nestedArrIndex: k,
                 value: item
               });
             });
-          } else ;
+          } else
+            ;
         }
         record.$[keyIndex] = subRecords;
       } else if (isString(value) && !isBlank(value)) {
@@ -392,31 +358,16 @@ class FuseIndex {
     };
   }
 }
-function createIndex(keys, docs, {
-  getFn = Config.getFn,
-  fieldNormWeight = Config.fieldNormWeight
-} = {}) {
-  const myIndex = new FuseIndex({
-    getFn,
-    fieldNormWeight
-  });
+function createIndex(keys, docs, { getFn = Config.getFn, fieldNormWeight = Config.fieldNormWeight } = {}) {
+  const myIndex = new FuseIndex({ getFn, fieldNormWeight });
   myIndex.setKeys(keys.map(createKey));
   myIndex.setSources(docs);
   myIndex.create();
   return myIndex;
 }
-function parseIndex(data, {
-  getFn = Config.getFn,
-  fieldNormWeight = Config.fieldNormWeight
-} = {}) {
-  const {
-    keys,
-    records
-  } = data;
-  const myIndex = new FuseIndex({
-    getFn,
-    fieldNormWeight
-  });
+function parseIndex(data, { getFn = Config.getFn, fieldNormWeight = Config.fieldNormWeight } = {}) {
+  const { keys, records } = data;
+  const myIndex = new FuseIndex({ getFn, fieldNormWeight });
   myIndex.setKeys(keys);
   myIndex.setIndexRecords(records);
   return myIndex;
@@ -434,8 +385,7 @@ function computeScore$1(pattern, {
   }
   const proximity = Math.abs(expectedLocation - currentLocation);
   if (!distance) {
-    // Dodge divide by zero error.
-    return proximity ? 1.0 : accuracy;
+    return proximity ? 1 : accuracy;
   }
   return accuracy + proximity / distance;
 }
@@ -456,15 +406,11 @@ function convertMaskToIndices(matchmask = [], minMatchCharLength = Config.minMat
       start = -1;
     }
   }
-
-  // (i-1 - start) + 1 => i - start
   if (matchmask[i - 1] && i - start >= minMatchCharLength) {
     indices.push([start, i - 1]);
   }
   return indices;
 }
-
-// Machine word size
 const MAX_BITS = 32;
 function search(text, pattern, patternAlphabet, {
   location = Config.location,
@@ -479,23 +425,13 @@ function search(text, pattern, patternAlphabet, {
     throw new Error(PATTERN_LENGTH_TOO_LARGE(MAX_BITS));
   }
   const patternLen = pattern.length;
-  // Set starting location at beginning text and initialize the alphabet.
   const textLen = text.length;
-  // Handle the case when location > text.length
   const expectedLocation = Math.max(0, Math.min(location, textLen));
-  // Highest score beyond which we give up.
   let currentThreshold = threshold;
-  // Is there a nearby exact match? (speedup)
   let bestLocation = expectedLocation;
-
-  // Performance: only computer matches when the minMatchCharLength > 1
-  // OR if `includeMatches` is true.
   const computeMatches = minMatchCharLength > 1 || includeMatches;
-  // A mask of the matches, used for building the indices
   const matchMask = computeMatches ? Array(textLen) : [];
   let index;
-
-  // Get all exact matches, here for speed up
   while ((index = text.indexOf(pattern, bestLocation)) > -1) {
     let score = computeScore$1(pattern, {
       currentLocation: index,
@@ -513,55 +449,41 @@ function search(text, pattern, patternAlphabet, {
       }
     }
   }
-
-  // Reset the best location
   bestLocation = -1;
   let lastBitArr = [];
   let finalScore = 1;
   let binMax = patternLen + textLen;
   const mask = 1 << patternLen - 1;
   for (let i = 0; i < patternLen; i += 1) {
-    // Scan for the best match; each iteration allows for one more error.
-    // Run a binary search to determine how far from the match location we can stray
-    // at this error level.
     let binMin = 0;
     let binMid = binMax;
     while (binMin < binMid) {
-      const score = computeScore$1(pattern, {
+      const score2 = computeScore$1(pattern, {
         errors: i,
         currentLocation: expectedLocation + binMid,
         expectedLocation,
         distance,
         ignoreLocation
       });
-      if (score <= currentThreshold) {
+      if (score2 <= currentThreshold) {
         binMin = binMid;
       } else {
         binMax = binMid;
       }
       binMid = Math.floor((binMax - binMin) / 2 + binMin);
     }
-
-    // Use the result from this iteration as the maximum for the next.
     binMax = binMid;
     let start = Math.max(1, expectedLocation - binMid + 1);
     let finish = findAllMatches ? textLen : Math.min(expectedLocation + binMid, textLen) + patternLen;
-
-    // Initialize the bit array
     let bitArr = Array(finish + 2);
     bitArr[finish + 1] = (1 << i) - 1;
     for (let j = finish; j >= start; j -= 1) {
       let currentLocation = j - 1;
       let charMatch = patternAlphabet[text.charAt(currentLocation)];
       if (computeMatches) {
-        // Speed up: quick bool to int conversion (i.e, `charMatch ? 1 : 0`)
         matchMask[currentLocation] = +!!charMatch;
       }
-
-      // First pass: exact match
       bitArr[j] = (bitArr[j + 1] << 1 | 1) & charMatch;
-
-      // Subsequent passes: fuzzy match
       if (i) {
         bitArr[j] |= (lastBitArr[j + 1] | lastBitArr[j]) << 1 | 1 | lastBitArr[j + 1];
       }
@@ -573,26 +495,16 @@ function search(text, pattern, patternAlphabet, {
           distance,
           ignoreLocation
         });
-
-        // This match will almost certainly be better than any existing match.
-        // But check anyway.
         if (finalScore <= currentThreshold) {
-          // Indeed it is
           currentThreshold = finalScore;
           bestLocation = currentLocation;
-
-          // Already passed `loc`, downhill from here on in.
           if (bestLocation <= expectedLocation) {
             break;
           }
-
-          // When passing `bestLocation`, don't exceed our current distance from `expectedLocation`.
           start = Math.max(1, 2 * expectedLocation - bestLocation);
         }
       }
     }
-
-    // No hope for a (better) match at greater error levels.
     const score = computeScore$1(pattern, {
       errors: i + 1,
       currentLocation: expectedLocation,
@@ -608,7 +520,7 @@ function search(text, pattern, patternAlphabet, {
   const result = {
     isMatch: bestLocation >= 0,
     // Count exact matches (those with a score of 0) to be "almost" exact
-    score: Math.max(0.001, finalScore)
+    score: Math.max(1e-3, finalScore)
   };
   if (computeMatches) {
     const indices = convertMaskToIndices(matchMask, minMatchCharLength);
@@ -654,10 +566,10 @@ class BitapSearch {
     if (!this.pattern.length) {
       return;
     }
-    const addChunk = (pattern, startIndex) => {
+    const addChunk = (pattern2, startIndex) => {
       this.chunks.push({
-        pattern,
-        alphabet: createPatternAlphabet(pattern),
+        pattern: pattern2,
+        alphabet: createPatternAlphabet(pattern2),
         startIndex
       });
     };
@@ -679,27 +591,20 @@ class BitapSearch {
     }
   }
   searchIn(text) {
-    const {
-      isCaseSensitive,
-      includeMatches
-    } = this.options;
+    const { isCaseSensitive, includeMatches } = this.options;
     if (!isCaseSensitive) {
       text = text.toLowerCase();
     }
-
-    // Exact match
     if (this.pattern === text) {
-      let result = {
+      let result2 = {
         isMatch: true,
         score: 0
       };
       if (includeMatches) {
-        result.indices = [[0, text.length - 1]];
+        result2.indices = [[0, text.length - 1]];
       }
-      return result;
+      return result2;
     }
-
-    // Otherwise, use Bitap algorithm
     const {
       location,
       distance,
@@ -711,16 +616,8 @@ class BitapSearch {
     let allIndices = [];
     let totalScore = 0;
     let hasMatches = false;
-    this.chunks.forEach(({
-      pattern,
-      alphabet,
-      startIndex
-    }) => {
-      const {
-        isMatch,
-        score,
-        indices
-      } = search(text, pattern, alphabet, {
+    this.chunks.forEach(({ pattern, alphabet, startIndex }) => {
+      const { isMatch, score, indices } = search(text, pattern, alphabet, {
         location: location + startIndex,
         distance,
         threshold,
@@ -757,21 +654,19 @@ class BaseMatch {
   static isSingleMatch(pattern) {
     return getMatch(pattern, this.singleRegex);
   }
-  search( /*text*/) {}
+  search() {
+  }
 }
 function getMatch(pattern, exp) {
   const matches = pattern.match(exp);
   return matches ? matches[1] : null;
 }
-
-// Token: 'file
-
 class ExactMatch extends BaseMatch {
   constructor(pattern) {
     super(pattern);
   }
   static get type() {
-    return 'exact';
+    return "exact";
   }
   static get multiRegex() {
     return /^="(.*)"$/;
@@ -788,15 +683,12 @@ class ExactMatch extends BaseMatch {
     };
   }
 }
-
-// Token: !fire
-
 class InverseExactMatch extends BaseMatch {
   constructor(pattern) {
     super(pattern);
   }
   static get type() {
-    return 'inverse-exact';
+    return "inverse-exact";
   }
   static get multiRegex() {
     return /^!"(.*)"$/;
@@ -814,15 +706,12 @@ class InverseExactMatch extends BaseMatch {
     };
   }
 }
-
-// Token: ^file
-
 class PrefixExactMatch extends BaseMatch {
   constructor(pattern) {
     super(pattern);
   }
   static get type() {
-    return 'prefix-exact';
+    return "prefix-exact";
   }
   static get multiRegex() {
     return /^\^"(.*)"$/;
@@ -839,15 +728,12 @@ class PrefixExactMatch extends BaseMatch {
     };
   }
 }
-
-// Token: !^fire
-
 class InversePrefixExactMatch extends BaseMatch {
   constructor(pattern) {
     super(pattern);
   }
   static get type() {
-    return 'inverse-prefix-exact';
+    return "inverse-prefix-exact";
   }
   static get multiRegex() {
     return /^!\^"(.*)"$/;
@@ -864,15 +750,12 @@ class InversePrefixExactMatch extends BaseMatch {
     };
   }
 }
-
-// Token: .file$
-
 class SuffixExactMatch extends BaseMatch {
   constructor(pattern) {
     super(pattern);
   }
   static get type() {
-    return 'suffix-exact';
+    return "suffix-exact";
   }
   static get multiRegex() {
     return /^"(.*)"\$$/;
@@ -889,15 +772,12 @@ class SuffixExactMatch extends BaseMatch {
     };
   }
 }
-
-// Token: !.file$
-
 class InverseSuffixExactMatch extends BaseMatch {
   constructor(pattern) {
     super(pattern);
   }
   static get type() {
-    return 'inverse-suffix-exact';
+    return "inverse-suffix-exact";
   }
   static get multiRegex() {
     return /^!"(.*)"\$$/;
@@ -938,7 +818,7 @@ class FuzzyMatch extends BaseMatch {
     });
   }
   static get type() {
-    return 'fuzzy';
+    return "fuzzy";
   }
   static get multiRegex() {
     return /^"(.*)"$/;
@@ -950,15 +830,12 @@ class FuzzyMatch extends BaseMatch {
     return this._bitapSearch.searchIn(text);
   }
 }
-
-// Token: 'file
-
 class IncludeMatch extends BaseMatch {
   constructor(pattern) {
     super(pattern);
   }
   static get type() {
-    return 'include';
+    return "include";
   }
   static get multiRegex() {
     return /^'"(.*)"$/;
@@ -971,8 +848,6 @@ class IncludeMatch extends BaseMatch {
     let index;
     const indices = [];
     const patternLen = this.pattern.length;
-
-    // Get all exact matches
     while ((index = text.indexOf(this.pattern, location)) > -1) {
       location = index + patternLen;
       indices.push([index, location - 1]);
@@ -985,26 +860,25 @@ class IncludeMatch extends BaseMatch {
     };
   }
 }
-
-// ❗Order is important. DO NOT CHANGE.
-const searchers = [ExactMatch, IncludeMatch, PrefixExactMatch, InversePrefixExactMatch, InverseSuffixExactMatch, SuffixExactMatch, InverseExactMatch, FuzzyMatch];
+const searchers = [
+  ExactMatch,
+  IncludeMatch,
+  PrefixExactMatch,
+  InversePrefixExactMatch,
+  InverseSuffixExactMatch,
+  SuffixExactMatch,
+  InverseExactMatch,
+  FuzzyMatch
+];
 const searchersLen = searchers.length;
-
-// Regex to split by spaces, but keep anything in quotes together
 const SPACE_RE = / +(?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)/;
-const OR_TOKEN = '|';
-
-// Return a 2D array representation of the query, for simpler parsing.
-// Example:
-// "^core go$ | rb$ | py$ xy$" => [["^core", "go$"], ["rb$"], ["py$", "xy$"]]
+const OR_TOKEN = "|";
 function parseQuery(pattern, options = {}) {
-  return pattern.split(OR_TOKEN).map(item => {
-    let query = item.trim().split(SPACE_RE).filter(item => item && !!item.trim());
+  return pattern.split(OR_TOKEN).map((item) => {
+    let query = item.trim().split(SPACE_RE).filter((item2) => item2 && !!item2.trim());
     let results = [];
     for (let i = 0, len = query.length; i < len; i += 1) {
       const queryItem = query[i];
-
-      // 1. Handle multiple query match (i.e, once that are quoted, like `"hello world"`)
       let found = false;
       let idx = -1;
       while (!found && ++idx < searchersLen) {
@@ -1018,8 +892,6 @@ function parseQuery(pattern, options = {}) {
       if (found) {
         continue;
       }
-
-      // 2. Handle single query matches (i.e, once that are *not* quoted)
       idx = -1;
       while (++idx < searchersLen) {
         const searcher = searchers[idx];
@@ -1033,39 +905,7 @@ function parseQuery(pattern, options = {}) {
     return results;
   });
 }
-
-// These extended matchers can return an array of matches, as opposed
-// to a singl match
-const MultiMatchSet = new Set([FuzzyMatch.type, IncludeMatch.type]);
-
-/**
- * Command-like searching
- * ======================
- *
- * Given multiple search terms delimited by spaces.e.g. `^jscript .python$ ruby !java`,
- * search in a given text.
- *
- * Search syntax:
- *
- * | Token       | Match type                 | Description                            |
- * | ----------- | -------------------------- | -------------------------------------- |
- * | `jscript`   | fuzzy-match                | Items that fuzzy match `jscript`       |
- * | `=scheme`   | exact-match                | Items that are `scheme`                |
- * | `'python`   | include-match              | Items that include `python`            |
- * | `!ruby`     | inverse-exact-match        | Items that do not include `ruby`       |
- * | `^java`     | prefix-exact-match         | Items that start with `java`           |
- * | `!^earlang` | inverse-prefix-exact-match | Items that do not start with `earlang` |
- * | `.js$`      | suffix-exact-match         | Items that end with `.js`              |
- * | `!.go$`     | inverse-suffix-exact-match | Items that do not end with `.go`       |
- *
- * A single pipe character acts as an OR operator. For example, the following
- * query matches entries that start with `core` and end with either`go`, `rb`,
- * or`py`.
- *
- * ```
- * ^core go$ | rb$ | py$
- * ```
- */
+const MultiMatchSet = /* @__PURE__ */ new Set([FuzzyMatch.type, IncludeMatch.type]);
 class ExtendedSearch {
   constructor(pattern, {
     isCaseSensitive = Config.isCaseSensitive,
@@ -1102,31 +942,18 @@ class ExtendedSearch {
         score: 1
       };
     }
-    const {
-      includeMatches,
-      isCaseSensitive
-    } = this.options;
+    const { includeMatches, isCaseSensitive } = this.options;
     text = isCaseSensitive ? text : text.toLowerCase();
     let numMatches = 0;
     let allIndices = [];
     let totalScore = 0;
-
-    // ORs
     for (let i = 0, qLen = query.length; i < qLen; i += 1) {
-      const searchers = query[i];
-
-      // Reset indices
+      const searchers2 = query[i];
       allIndices.length = 0;
       numMatches = 0;
-
-      // ANDs
-      for (let j = 0, pLen = searchers.length; j < pLen; j += 1) {
-        const searcher = searchers[j];
-        const {
-          isMatch,
-          indices,
-          score
-        } = searcher.search(text);
+      for (let j = 0, pLen = searchers2.length; j < pLen; j += 1) {
+        const searcher = searchers2[j];
+        const { isMatch, indices, score } = searcher.search(text);
         if (isMatch) {
           numMatches += 1;
           totalScore += score;
@@ -1145,8 +972,6 @@ class ExtendedSearch {
           break;
         }
       }
-
-      // OR condition, so if TRUE, return
       if (numMatches) {
         let result = {
           isMatch: true,
@@ -1158,8 +983,6 @@ class ExtendedSearch {
         return result;
       }
     }
-
-    // Nothing was matched
     return {
       isMatch: false,
       score: 1
@@ -1180,36 +1003,31 @@ function createSearcher(pattern, options) {
   return new BitapSearch(pattern, options);
 }
 const LogicalOperator = {
-  AND: '$and',
-  OR: '$or'
+  AND: "$and",
+  OR: "$or"
 };
 const KeyType = {
-  PATH: '$path',
-  PATTERN: '$val'
+  PATH: "$path",
+  PATTERN: "$val"
 };
-const isExpression = query => !!(query[LogicalOperator.AND] || query[LogicalOperator.OR]);
-const isPath = query => !!query[KeyType.PATH];
-const isLeaf = query => !isArray(query) && isObject(query) && !isExpression(query);
-const convertToExplicit = query => ({
-  [LogicalOperator.AND]: Object.keys(query).map(key => ({
+const isExpression = (query) => !!(query[LogicalOperator.AND] || query[LogicalOperator.OR]);
+const isPath = (query) => !!query[KeyType.PATH];
+const isLeaf = (query) => !isArray(query) && isObject(query) && !isExpression(query);
+const convertToExplicit = (query) => ({
+  [LogicalOperator.AND]: Object.keys(query).map((key) => ({
     [key]: query[key]
   }))
 });
-
-// When `auto` is `true`, the parse function will infer and initialize and add
-// the appropriate `Searcher` instance
-function parse(query, options, {
-  auto = true
-} = {}) {
-  const next = query => {
-    let keys = Object.keys(query);
-    const isQueryPath = isPath(query);
-    if (!isQueryPath && keys.length > 1 && !isExpression(query)) {
-      return next(convertToExplicit(query));
+function parse(query, options, { auto = true } = {}) {
+  const next = (query2) => {
+    let keys = Object.keys(query2);
+    const isQueryPath = isPath(query2);
+    if (!isQueryPath && keys.length > 1 && !isExpression(query2)) {
+      return next(convertToExplicit(query2));
     }
-    if (isLeaf(query)) {
-      const key = isQueryPath ? query[KeyType.PATH] : keys[0];
-      const pattern = isQueryPath ? query[KeyType.PATTERN] : query[key];
+    if (isLeaf(query2)) {
+      const key = isQueryPath ? query2[KeyType.PATH] : keys[0];
+      const pattern = isQueryPath ? query2[KeyType.PATTERN] : query2[key];
       if (!isString(pattern)) {
         throw new Error(LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY(key));
       }
@@ -1226,10 +1044,10 @@ function parse(query, options, {
       children: [],
       operator: keys[0]
     };
-    keys.forEach(key => {
-      const value = query[key];
+    keys.forEach((key) => {
+      const value = query2[key];
       if (isArray(value)) {
-        value.forEach(item => {
+        value.forEach((item) => {
           node.children.push(next(item));
         });
       }
@@ -1241,20 +1059,15 @@ function parse(query, options, {
   }
   return next(query);
 }
-
-// Practical scoring function
-function computeScore(results, {
-  ignoreFieldNorm = Config.ignoreFieldNorm
-}) {
-  results.forEach(result => {
+function computeScore(results, { ignoreFieldNorm = Config.ignoreFieldNorm }) {
+  results.forEach((result) => {
     let totalScore = 1;
-    result.matches.forEach(({
-      key,
-      norm,
-      score
-    }) => {
+    result.matches.forEach(({ key, norm: norm2, score }) => {
       const weight = key ? key.weight : null;
-      totalScore *= Math.pow(score === 0 && weight ? Number.EPSILON : score, (weight || 1) * (ignoreFieldNorm ? 1 : norm));
+      totalScore *= Math.pow(
+        score === 0 && weight ? Number.EPSILON : score,
+        (weight || 1) * (ignoreFieldNorm ? 1 : norm2)
+      );
     });
     result.score = totalScore;
   });
@@ -1265,14 +1078,11 @@ function transformMatches(result, data) {
   if (!isDefined(matches)) {
     return;
   }
-  matches.forEach(match => {
+  matches.forEach((match) => {
     if (!isDefined(match.indices) || !match.indices.length) {
       return;
     }
-    const {
-      indices,
-      value
-    } = match;
+    const { indices, value } = match;
     let obj = {
       indices,
       value
@@ -1294,18 +1104,18 @@ function format(results, docs, {
   includeScore = Config.includeScore
 } = {}) {
   const transformers = [];
-  if (includeMatches) transformers.push(transformMatches);
-  if (includeScore) transformers.push(transformScore);
-  return results.map(result => {
-    const {
-      idx
-    } = result;
+  if (includeMatches)
+    transformers.push(transformMatches);
+  if (includeScore)
+    transformers.push(transformScore);
+  return results.map((result) => {
+    const { idx } = result;
     const data = {
       item: docs[idx],
       refIndex: idx
     };
     if (transformers.length) {
-      transformers.forEach(transformer => {
+      transformers.forEach((transformer) => {
         transformer(result, data);
       });
     }
@@ -1314,11 +1124,8 @@ function format(results, docs, {
 }
 class Fuse {
   constructor(docs, options = {}, index) {
-    this.options = {
-      ...Config,
-      ...options
-    };
-    if (this.options.useExtendedSearch && !true) {
+    this.options = { ...Config, ...options };
+    if (this.options.useExtendedSearch && false) {
       throw new Error(EXTENDED_SEARCH_UNAVAILABLE);
     }
     this._keyStore = new KeyStore(this.options.keys);
@@ -1341,7 +1148,7 @@ class Fuse {
     this._docs.push(doc);
     this._myIndex.add(doc);
   }
-  remove(predicate = ( /* doc, idx */) => false) {
+  remove(predicate = () => false) {
     const results = [];
     for (let i = 0, len = this._docs.length; i < len; i += 1) {
       const doc = this._docs[i];
@@ -1361,9 +1168,7 @@ class Fuse {
   getIndex() {
     return this._myIndex;
   }
-  search(query, {
-    limit = -1
-  } = {}) {
+  search(query, { limit = -1 } = {}) {
     const {
       includeMatches,
       includeScore,
@@ -1372,9 +1177,7 @@ class Fuse {
       ignoreFieldNorm
     } = this.options;
     let results = isString(query) ? isString(this._docs[0]) ? this._searchStringList(query) : this._searchObjectList(query) : this._searchLogical(query);
-    computeScore(results, {
-      ignoreFieldNorm
-    });
+    computeScore(results, { ignoreFieldNorm });
     if (shouldSort) {
       results.sort(sortFn);
     }
@@ -1388,35 +1191,18 @@ class Fuse {
   }
   _searchStringList(query) {
     const searcher = createSearcher(query, this.options);
-    const {
-      records
-    } = this._myIndex;
+    const { records } = this._myIndex;
     const results = [];
-
-    // Iterate over every string in the index
-    records.forEach(({
-      v: text,
-      i: idx,
-      n: norm
-    }) => {
+    records.forEach(({ v: text, i: idx, n: norm2 }) => {
       if (!isDefined(text)) {
         return;
       }
-      const {
-        isMatch,
-        score,
-        indices
-      } = searcher.searchIn(text);
+      const { isMatch, score, indices } = searcher.searchIn(text);
       if (isMatch) {
         results.push({
           item: text,
           idx,
-          matches: [{
-            score,
-            value: text,
-            norm,
-            indices
-          }]
+          matches: [{ score, value: text, norm: norm2, indices }]
         });
       }
     });
@@ -1426,21 +1212,20 @@ class Fuse {
     const expression = parse(query, this.options);
     const evaluate = (node, item, idx) => {
       if (!node.children) {
-        const {
-          keyId,
-          searcher
-        } = node;
+        const { keyId, searcher } = node;
         const matches = this._findMatches({
           key: this._keyStore.get(keyId),
           value: this._myIndex.getValueForItemAtKeyId(item, keyId),
           searcher
         });
         if (matches && matches.length) {
-          return [{
-            idx,
-            item,
-            matches
-          }];
+          return [
+            {
+              idx,
+              item,
+              matches
+            }
+          ];
         }
         return [];
       }
@@ -1459,25 +1244,15 @@ class Fuse {
     const records = this._myIndex.records;
     const resultMap = {};
     const results = [];
-    records.forEach(({
-      $: item,
-      i: idx
-    }) => {
+    records.forEach(({ $: item, i: idx }) => {
       if (isDefined(item)) {
         let expResults = evaluate(expression, item, idx);
         if (expResults.length) {
-          // Dedupe when adding
           if (!resultMap[idx]) {
-            resultMap[idx] = {
-              idx,
-              item,
-              matches: []
-            };
+            resultMap[idx] = { idx, item, matches: [] };
             results.push(resultMap[idx]);
           }
-          expResults.forEach(({
-            matches
-          }) => {
+          expResults.forEach(({ matches }) => {
             resultMap[idx].matches.push(...matches);
           });
         }
@@ -1487,29 +1262,21 @@ class Fuse {
   }
   _searchObjectList(query) {
     const searcher = createSearcher(query, this.options);
-    const {
-      keys,
-      records
-    } = this._myIndex;
+    const { keys, records } = this._myIndex;
     const results = [];
-
-    // List is Array<Object>
-    records.forEach(({
-      $: item,
-      i: idx
-    }) => {
+    records.forEach(({ $: item, i: idx }) => {
       if (!isDefined(item)) {
         return;
       }
       let matches = [];
-
-      // Iterate over every key (i.e, path), and fetch the value at that key
       keys.forEach((key, keyIndex) => {
-        matches.push(...this._findMatches({
-          key,
-          value: item[keyIndex],
-          searcher
-        }));
+        matches.push(
+          ...this._findMatches({
+            key,
+            value: item[keyIndex],
+            searcher
+          })
+        );
       });
       if (matches.length) {
         results.push({
@@ -1521,64 +1288,39 @@ class Fuse {
     });
     return results;
   }
-  _findMatches({
-    key,
-    value,
-    searcher
-  }) {
+  _findMatches({ key, value, searcher }) {
     if (!isDefined(value)) {
       return [];
     }
     let matches = [];
     if (isArray(value)) {
-      value.forEach(({
-        v: text,
-        i: idx,
-        n: norm
-      }) => {
+      value.forEach(({ v: text, i: idx, n: norm2 }) => {
         if (!isDefined(text)) {
           return;
         }
-        const {
-          isMatch,
-          score,
-          indices
-        } = searcher.searchIn(text);
+        const { isMatch, score, indices } = searcher.searchIn(text);
         if (isMatch) {
           matches.push({
             score,
             key,
             value: text,
             idx,
-            norm,
+            norm: norm2,
             indices
           });
         }
       });
     } else {
-      const {
-        v: text,
-        n: norm
-      } = value;
-      const {
-        isMatch,
-        score,
-        indices
-      } = searcher.searchIn(text);
+      const { v: text, n: norm2 } = value;
+      const { isMatch, score, indices } = searcher.searchIn(text);
       if (isMatch) {
-        matches.push({
-          score,
-          key,
-          value: text,
-          norm,
-          indices
-        });
+        matches.push({ score, key, value: text, norm: norm2, indices });
       }
     }
     return matches;
   }
 }
-Fuse.version = '6.6.2';
+Fuse.version = "6.6.2";
 Fuse.createIndex = createIndex;
 Fuse.parseIndex = parseIndex;
 Fuse.config = Config;
@@ -1588,6 +1330,309 @@ Fuse.config = Config;
 {
   register(ExtendedSearch);
 }
-
-export default Fuse;
-//# sourceMappingURL=fusejs.js.map
+function uniqID() {
+  return "_" + (Math.random() * Math.pow(36, 20)).toString(36).slice(0, 10);
+}
+function stringToDom(html) {
+  const template = document.createElement("template");
+  template.innerHTML = html;
+  return template.content;
+}
+async function evalTemplateString(str, variables = {}) {
+  const keys = Object.keys(variables);
+  const values = keys.map((key) => variables[key]);
+  try {
+    const AsyncFunction = Object.getPrototypeOf(async function() {
+    }).constructor;
+    const func = AsyncFunction.call(null, ...keys, "return `" + str + "`");
+    return await func(...values);
+  } catch (e) {
+    console.log(e);
+    throw new SyntaxError("`" + str + "`");
+  }
+}
+function importCSS(...stylesheets) {
+  const linksElements = [];
+  for (let url of stylesheets) {
+    url = relativeSource(url);
+    let link = Array.from(document.head.querySelectorAll("link")).find(
+      (link2) => link2.href === url
+    );
+    if (link)
+      return link;
+    link = document.createElement("link");
+    link.rel = "stylesheet";
+    link.href = url;
+    document.head.appendChild(link);
+    linksElements.push(link);
+  }
+  return linksElements;
+}
+function importJS(...plugins) {
+  return plugins.map((url) => {
+    url = new URL(url, document.baseURI).href;
+    let script = Array.from(document.querySelectorAll("script")).find(
+      (script2) => script2.src === url
+    );
+    if (script)
+      return script;
+    script = document.createElement("script");
+    script.src = url;
+    document.head.appendChild(script);
+    return script;
+  });
+}
+function relativeSource(source) {
+  if (!source.match(/^\..?\//))
+    return new URL(source, document.baseURI).href;
+  const e = new Error();
+  if (!e.stack)
+    return source;
+  const f2 = e.stack.split("\n").filter((l) => l.includes(":"))[2];
+  let line = f2.match(/[a-z]+:.*$/);
+  if (!line)
+    return source;
+  const calledFile = line[0].replace(/(\:[0-9]+){2}\)?$/, "");
+  source = new URL(source, calledFile).href;
+  return source;
+}
+function loadScript(source) {
+  source = relativeSource(source);
+  return new Promise((resolve) => {
+    var script = document.createElement("script");
+    var head = document.querySelector("head");
+    script.async = true;
+    script.onload = () => setTimeout(resolve, 0);
+    script.src = source;
+    if (head)
+      head.appendChild(script);
+  });
+}
+function domIsReady() {
+  return new Promise(function(resolve) {
+    if (document.readyState === "complete") {
+      resolve();
+    } else {
+      document.addEventListener("DOMContentLoaded", () => resolve());
+    }
+  });
+}
+function setDeepProperty(obj, path, value) {
+  const name = path.shift();
+  if (name) {
+    if (!(name in obj))
+      obj[name] = {};
+    if (path.length)
+      setDeepProperty(obj[name], path, value);
+    else
+      obj[name] = value;
+  }
+}
+function parseFieldsString(fields) {
+  let fieldsArray;
+  while (fields.indexOf("(") > 0) {
+    let firstBracket = fields.indexOf("(");
+    let noset = fields.substring(firstBracket, findClosingBracketMatchIndex(fields, firstBracket) + 1);
+    fields = fields.replace(noset, "");
+  }
+  const re = /((^\s*|,)\s*)(("(\\"|[^"])*")|('(\\'|[^'])*')|[^,]*)/gm;
+  fieldsArray = fields.match(re) || [];
+  if (!fieldsArray)
+    return [];
+  return fieldsArray.map((a) => a.replace(/^[\s,]+/, ""));
+}
+function findClosingBracketMatchIndex(str, pos) {
+  if (str[pos] != "(")
+    throw new Error("No '(' at index " + pos);
+  let depth = 1;
+  for (let i = pos + 1; i < str.length; i++) {
+    switch (str[i]) {
+      case "(":
+        depth++;
+        break;
+      case ")":
+        if (--depth == 0)
+          return i;
+        break;
+    }
+  }
+  return -1;
+}
+function defineComponent(tagName, componentClass) {
+  if (!customElements.get(tagName)) {
+    customElements.define(tagName, componentClass);
+  } else {
+    console.warn(`Warning: the component "${tagName}" has already been loaded in another version of sib-core.`);
+  }
+}
+function fuzzyCompare(subject, search2) {
+  const fuse = new Fuse([subject], {
+    shouldSort: false,
+    threshold: 0.37
+  }).search(search2);
+  return fuse.length > 0;
+}
+const compare = {
+  string(subject, query) {
+    if (query === "")
+      return true;
+    if (subject.toString().toLowerCase().includes(String(query).toLowerCase()))
+      return true;
+    return fuzzyCompare(subject, query);
+  },
+  boolean(subject, query) {
+    if (!query)
+      return true;
+    return subject;
+  },
+  number(subject, query) {
+    return subject === query;
+  },
+  list(subject, list) {
+    return list.includes(subject);
+  },
+  range(subject, range) {
+    return (range[0] == null || range[0] === "" || subject >= range[0]) && (range[1] == null || range[1] === "" || subject <= range[1]);
+  },
+  resource(subject, query) {
+    if (query === "")
+      return true;
+    if (!query["@id"])
+      return false;
+    const ret = subject["@id"] === query["@id"];
+    return ret;
+  }
+};
+function transformArrayToContainer(resource) {
+  const newValue = { ...resource };
+  for (let predicate of Object.keys(newValue)) {
+    const predicateValue = newValue[predicate];
+    if (!predicateValue || typeof predicateValue !== "object")
+      continue;
+    if (["permissions", "@context"].includes(predicate))
+      continue;
+    if (!Array.isArray(predicateValue) && predicateValue["@id"]) {
+      newValue[predicate] = transformArrayToContainer(resource[predicate]);
+    }
+    if (Array.isArray(predicateValue)) {
+      newValue[predicate] = { "ldp:contains": [...predicateValue] };
+      newValue[predicate]["ldp:contains"].forEach((childPredicate, index) => {
+        newValue[predicate]["ldp:contains"][index] = transformArrayToContainer(childPredicate);
+      });
+    }
+  }
+  return newValue;
+}
+class AsyncIterableBuilder {
+  constructor() {
+    __privateAdd(this, _createIterable);
+    __privateAdd(this, _next);
+    __privateAdd(this, _nextPromise);
+    __privateAdd(this, _values, void 0);
+    __privateAdd(this, _resolve, void 0);
+    __privateSet(this, _values, []);
+    __privateMethod(this, _nextPromise, nextPromise_fn).call(this);
+    this.iterable = __privateMethod(this, _createIterable, createIterable_fn).call(this);
+    this.next = __privateMethod(this, _next, next_fn).bind(this);
+  }
+}
+_values = new WeakMap();
+_resolve = new WeakMap();
+_createIterable = new WeakSet();
+createIterable_fn = async function* () {
+  for (let index = 0; ; index++) {
+    const { value, done } = await __privateGet(this, _values)[index];
+    delete __privateGet(this, _values)[index];
+    yield value;
+    if (done)
+      return;
+  }
+};
+_next = new WeakSet();
+next_fn = function(value, done = false) {
+  __privateGet(this, _resolve).call(this, { value, done });
+  __privateMethod(this, _nextPromise, nextPromise_fn).call(this);
+};
+_nextPromise = new WeakSet();
+nextPromise_fn = function() {
+  __privateGet(this, _values).push(new Promise((resolve) => __privateSet(this, _resolve, resolve)));
+};
+const asyncQuerySelector = (selector, parent = document) => new Promise((resolve) => {
+  const element = parent.querySelector(selector);
+  if (element)
+    return resolve(element);
+  const observer = new MutationObserver(() => {
+    const element2 = parent.querySelector(selector);
+    if (!element2)
+      return;
+    observer.disconnect();
+    return resolve(element2);
+  });
+  observer.observe(parent, {
+    subtree: true,
+    childList: true,
+    attributes: true
+  });
+});
+const asyncQuerySelectorAll = (selector, parent = document) => {
+  const delivered = /* @__PURE__ */ new WeakSet();
+  const { next, iterable } = new AsyncIterableBuilder();
+  function checkNewElement() {
+    for (const element of parent.querySelectorAll(selector)) {
+      if (delivered.has(element))
+        continue;
+      delivered.add(element);
+      next(element);
+    }
+  }
+  checkNewElement();
+  const observer = new MutationObserver(checkNewElement);
+  observer.observe(parent, {
+    subtree: true,
+    childList: true,
+    attributes: true
+  });
+  return iterable;
+};
+const helpers = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  AsyncIterableBuilder,
+  asyncQuerySelector,
+  asyncQuerySelectorAll,
+  compare,
+  default: AsyncIterableBuilder,
+  defineComponent,
+  domIsReady,
+  evalTemplateString,
+  findClosingBracketMatchIndex,
+  fuzzyCompare,
+  importCSS,
+  importJS,
+  loadScript,
+  parseFieldsString,
+  setDeepProperty,
+  stringToDom,
+  transformArrayToContainer,
+  uniqID
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  AsyncIterableBuilder as A,
+  findClosingBracketMatchIndex as a,
+  stringToDom as b,
+  compare as c,
+  defineComponent as d,
+  evalTemplateString as e,
+  fuzzyCompare as f,
+  importJS as g,
+  helpers as h,
+  importCSS as i,
+  domIsReady as j,
+  asyncQuerySelector as k,
+  loadScript as l,
+  asyncQuerySelectorAll as m,
+  parseFieldsString as p,
+  setDeepProperty as s,
+  transformArrayToContainer as t,
+  uniqID as u
+};
+//# sourceMappingURL=helpers-411e08e4.js.map