@verdaccio/search 6.0.0-6-next.2 → 7.0.0-next.0

package/build/dist.js

@@ -322,8 +322,8 @@ var require_common = __commonJS({
 var require_browser = __commonJS({
   "../../node_modules/.pnpm/debug@4.3.4_supports-color@6.1.0/node_modules/debug/src/browser.js"(exports, module2) {
     exports.formatArgs = formatArgs;
-    exports.save = save3;
-    exports.load = load3;
+    exports.save = save5;
+    exports.load = load5;
     exports.useColors = useColors;
     exports.storage = localstorage();
     exports.destroy = (() => {
@@ -444,7 +444,7 @@ var require_browser = __commonJS({
     }
     exports.log = console.debug || console.log || (() => {
     });
-    function save3(namespaces) {
+    function save5(namespaces) {
       try {
         if (namespaces) {
           exports.storage.setItem("debug", namespaces);
@@ -454,7 +454,7 @@ var require_browser = __commonJS({
       } catch (error) {
       }
     }
-    function load3() {
+    function load5() {
       let r;
       try {
         r = exports.storage.getItem("debug");
@@ -606,8 +606,8 @@ var require_node = __commonJS({
     exports.init = init;
     exports.log = log;
     exports.formatArgs = formatArgs;
-    exports.save = save3;
-    exports.load = load3;
+    exports.save = save5;
+    exports.load = load5;
     exports.useColors = useColors;
     exports.destroy = util.deprecate(() => {
     }, "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
@@ -739,14 +739,14 @@ var require_node = __commonJS({
     function log(...args) {
       return process.stderr.write(util.format(...args) + "\n");
     }
-    function save3(namespaces) {
+    function save5(namespaces) {
       if (namespaces) {
         process.env.DEBUG = namespaces;
       } else {
         delete process.env.DEBUG;
       }
     }
-    function load3() {
+    function load5() {
       return process.env.DEBUG;
     }
     function init(debug2) {
@@ -786,7 +786,7 @@ __export(src_exports, {
   SearchMemoryIndexer: () => indexer_default
 });
 
-// ../../node_modules/.pnpm/@orama+orama@1.0.0-beta.16/node_modules/@orama/orama/dist/components/tokenizer/languages.js
+// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/components/tokenizer/languages.js
 var STEMMERS = {
   arabic: "ar",
   armenian: "am",
@@ -813,6 +813,7 @@ var STEMMERS = {
   slovenian: "ru",
   spanish: "es",
   swedish: "se",
+  tamil: "ta",
   turkish: "tr",
   ukrainian: "uk"
 };
@@ -843,11 +844,12 @@ var SPLITTERS = {
   indonesian: /[^a-z0-9]+/gim,
   ukrainian: /[^a-z0-9а-яА-ЯіїєІЇЄ]+/gim,
   slovenian: /[^a-z0-9螚ȎŠ]+/gim,
-  bulgarian: /[^a-z0-9а-яА-Я]+/gim
+  bulgarian: /[^a-z0-9а-яА-Я]+/gim,
+  tamil: /[^a-z0-9அ-ஹ]+/gim
 };
 var SUPPORTED_LANGUAGES = Object.keys(STEMMERS);
 
-// ../../node_modules/.pnpm/@orama+orama@1.0.0-beta.16/node_modules/@orama/orama/dist/utils.js
+// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/utils.js
 var baseId = Date.now().toString().slice(5);
 var lastId = 0;
 var nano = BigInt(1e3);
@@ -902,9 +904,6 @@ async function getNanosecondsTime() {
 async function uniqueId() {
   return `${baseId}-${lastId++}`;
 }
-function syncUniqueId() {
-  return `${baseId}-${lastId++}`;
-}
 function getOwnProperty(object, property) {
   if (Object.hasOwn === void 0) {
     return Object.prototype.hasOwnProperty.call(object, property) ? object[property] : void 0;
@@ -913,7 +912,7 @@ function getOwnProperty(object, property) {
 }
 function sortTokenScorePredicate(a, b) {
   if (b[1] === a[1]) {
-    return a[0].localeCompare(b[0]);
+    return a[0] - b[0];
   }
   return b[1] - a[1];
 }
@@ -963,7 +962,7 @@ async function getDocumentProperties(doc, paths) {
     const pathTokensLength = pathTokens.length;
     for (let j = 0; j < pathTokensLength; j++) {
       current = current[pathTokens[j]];
-      if (typeof current === "object" && current !== null && j === pathTokensLength - 1) {
+      if (typeof current === "object" && !Array.isArray(current) && current !== null && j === pathTokensLength - 1) {
         current = void 0;
         break;
       } else if ((current === null || typeof current !== "object") && j < pathTokensLength - 1) {
@@ -984,7 +983,7 @@ async function getNested(obj, path) {
   return props[path];
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.0.0-beta.16/node_modules/@orama/orama/dist/errors.js
+// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/errors.js
 var allLanguages = SUPPORTED_LANGUAGES.join("\n - ");
 var errors = {
   NO_LANGUAGE_WITH_CUSTOM_TOKENIZER: "Do not pass the language option to create when using a custom tokenizer.",
@@ -997,7 +996,7 @@ Supported languages are:
   UNSUPPORTED_COMPONENT: `Unsupported component "%s".`,
   COMPONENT_MUST_BE_FUNCTION: `The component "%s" must be a function.`,
   COMPONENT_MUST_BE_FUNCTION_OR_ARRAY_FUNCTIONS: `The component "%s" must be a function or an array of functions.`,
-  INVALID_SCHEMA_TYPE: `Unsupported schema type "%s". Expected "string", "boolean" or "number".`,
+  INVALID_SCHEMA_TYPE: `Unsupported schema type "%s" at "%s". Expected "string", "boolean" or "number" or array of them.`,
   DOCUMENT_ID_MUST_BE_STRING: `Document id must be of type "string". Got "%s" instead.`,
   DOCUMENT_ALREADY_EXISTS: `A document with id "%s" already exists.`,
   DOCUMENT_DOES_NOT_EXIST: `A document with id "%s" does not exists.`,
@@ -1005,7 +1004,15 @@ Supported languages are:
   INVALID_DOCUMENT_PROPERTY: `Invalid document property "%s": expected "%s", got "%s"`,
   UNKNOWN_INDEX: `Invalid property name "%s". Expected a wildcard string ("*") or array containing one of the following properties: %s`,
   INVALID_BOOST_VALUE: `Boost value must be a number greater than, or less than 0.`,
-  INVALID_FILTER_OPERATION: `You can only use one operation per filter, you requested %d.`
+  INVALID_FILTER_OPERATION: `You can only use one operation per filter, you requested %d.`,
+  SCHEMA_VALIDATION_FAILURE: `Cannot insert document due schema validation failure on "%s" property.`,
+  INVALID_SORT_SCHEMA_TYPE: `Unsupported sort schema type "%s" at "%s". Expected "string" or "number".`,
+  CANNOT_SORT_BY_ARRAY: `Cannot configure sort for "%s" because it is an array (%s).`,
+  UNABLE_TO_SORT_ON_UNKNOWN_FIELD: `Unable to sort on unknown field "%s". Allowed fields: %s`,
+  SORT_DISABLED: `Sort is disabled. Please read the documentation at https://docs.oramasearch for more information.`,
+  UNKNOWN_GROUP_BY_PROPERTY: `Unknown groupBy property "%s".`,
+  INVALID_GROUP_BY_PROPERTY: `Invalid groupBy property "%s". Allowed types: "%s", but given "%s".`,
+  UNKNOWN_FILTER_PROPERTY: `Unknown filter property "%s".`
 };
 function createError(code, ...args) {
   var _a2;
@@ -1017,7 +1024,7 @@ function createError(code, ...args) {
   return error;
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.0.0-beta.16/node_modules/@orama/orama/dist/components/defaults.js
+// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/components/defaults.js
 async function formatElapsedTime(n) {
   return {
     raw: Number(n),
@@ -1035,37 +1042,126 @@ async function getDocumentIndexId(doc) {
 }
 async function validateSchema(doc, schema) {
   for (const [prop, type] of Object.entries(schema)) {
-    if (typeof type === "object") {
-      if (!doc[prop] || typeof doc[prop] !== "object" && Array.isArray(doc[prop])) {
-        return false;
+    const value = doc[prop];
+    const typeOfValue = typeof value;
+    if (typeOfValue === "undefined") {
+      continue;
+    }
+    const typeOfType = typeof type;
+    if (typeOfType === "string" && isArrayType(type)) {
+      if (!Array.isArray(value)) {
+        return prop;
       }
-      if (!validateSchema(doc[prop], type)) {
-        return false;
+      const expectedType = getInnerType(type);
+      const valueLength = value.length;
+      for (let i = 0; i < valueLength; i++) {
+        if (typeof value[i] !== expectedType) {
+          return prop + "." + i;
+        }
       }
+      continue;
     }
-    if (typeof doc[prop] !== type) {
-      return false;
+    if (typeOfType === "object") {
+      if (!value || typeOfValue !== "object") {
+        return prop;
+      }
+      const subProp = await validateSchema(value, type);
+      if (subProp) {
+        return prop + "." + subProp;
+      }
+      continue;
+    }
+    if (typeOfValue !== type) {
+      return prop;
     }
   }
-  return true;
+  return void 0;
+}
+var IS_ARRAY_TYPE = {
+  string: false,
+  number: false,
+  boolean: false,
+  "string[]": true,
+  "number[]": true,
+  "boolean[]": true
+};
+var INNER_TYPE = {
+  "string[]": "string",
+  "number[]": "number",
+  "boolean[]": "boolean"
+};
+function isArrayType(type) {
+  return IS_ARRAY_TYPE[type];
+}
+function getInnerType(type) {
+  return INNER_TYPE[type];
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.0.0-beta.16/node_modules/@orama/orama/dist/components/documents-store.js
-async function create() {
+// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/components/internal-document-id-store.js
+function createInternalDocumentIDStore() {
+  return {
+    idToInternalId: /* @__PURE__ */ new Map(),
+    internalIdToId: [],
+    save,
+    load
+  };
+}
+function save(store2) {
   return {
+    internalIdToId: store2.internalIdToId
+  };
+}
+function load(orama, raw) {
+  const { internalIdToId } = raw;
+  orama.internalDocumentIDStore.idToInternalId.clear();
+  orama.internalDocumentIDStore.internalIdToId = [];
+  for (let i = 0; i < internalIdToId.length; i++) {
+    orama.internalDocumentIDStore.idToInternalId.set(internalIdToId[i], i + 1);
+    orama.internalDocumentIDStore.internalIdToId.push(internalIdToId[i]);
+  }
+}
+function getInternalDocumentId(store2, id) {
+  if (typeof id === "string") {
+    const internalId = store2.idToInternalId.get(id);
+    if (internalId) {
+      return internalId;
+    }
+    const currentId = store2.idToInternalId.size + 1;
+    store2.idToInternalId.set(id, currentId);
+    store2.internalIdToId.push(id);
+    return currentId;
+  }
+  if (id > store2.internalIdToId.length) {
+    return getInternalDocumentId(store2, id.toString());
+  }
+  return id;
+}
+function getDocumentIdFromInternalId(store2, internalId) {
+  if (store2.internalIdToId.length < internalId) {
+    throw new Error(`Invalid internalId ${internalId}`);
+  }
+  return store2.internalIdToId[internalId - 1];
+}
+
+// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/components/documents-store.js
+async function create(_, sharedInternalDocumentStore) {
+  return {
+    sharedInternalDocumentStore,
     docs: {},
     count: 0
   };
 }
 async function get(store2, id) {
-  return store2.docs[id];
+  const internalId = getInternalDocumentId(store2.sharedInternalDocumentStore, id);
+  return store2.docs[internalId];
 }
 async function getMultiple(store2, ids) {
   const found = Array.from({
     length: ids.length
   });
   for (let i = 0; i < ids.length; i++) {
-    found[i] = store2.docs[ids[i]];
+    const internalId = getInternalDocumentId(store2.sharedInternalDocumentStore, ids[i]);
+    found[i] = store2.docs[internalId];
   }
   return found;
 }
@@ -1073,35 +1169,38 @@ async function getAll(store2) {
   return store2.docs;
 }
 async function store(store2, id, doc) {
-  if (typeof store2.docs[id] !== "undefined") {
+  const internalId = getInternalDocumentId(store2.sharedInternalDocumentStore, id);
+  if (typeof store2.docs[internalId] !== "undefined") {
     return false;
   }
-  store2.docs[id] = doc;
+  store2.docs[internalId] = doc;
   store2.count++;
   return true;
 }
 async function remove(store2, id) {
-  if (typeof store2.docs[id] === "undefined") {
+  const internalId = getInternalDocumentId(store2.sharedInternalDocumentStore, id);
+  if (typeof store2.docs[internalId] === "undefined") {
     return false;
   }
-  store2.docs[id] = void 0;
+  delete store2.docs[internalId];
   store2.count--;
   return true;
 }
 async function count(store2) {
   return store2.count;
 }
-async function load(raw) {
+async function load2(sharedInternalDocumentStore, raw) {
   const rawDocument = raw;
   return {
     docs: rawDocument.docs,
-    count: rawDocument.count
+    count: rawDocument.count,
+    sharedInternalDocumentStore
   };
 }
-async function save(docs) {
+async function save2(store2) {
   return {
-    docs: docs.docs,
-    count: docs.count
+    docs: store2.docs,
+    count: store2.count
   };
 }
 async function createDocumentsStore() {
@@ -1113,16 +1212,17 @@ async function createDocumentsStore() {
     store,
     remove,
     count,
-    load,
-    save
+    load: load2,
+    save: save2
   };
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.0.0-beta.16/node_modules/@orama/orama/dist/components/hooks.js
+// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/components/hooks.js
 var OBJECT_COMPONENTS = [
   "tokenizer",
   "index",
-  "documentsStore"
+  "documentsStore",
+  "sorter"
 ];
 var FUNCTION_COMPONENTS = [
   "validateSchema",
@@ -1137,6 +1237,7 @@ var SINGLE_OR_ARRAY_COMPONENTS = [
   "afterRemove",
   "beforeUpdate",
   "afterUpdate",
+  "afterSearch",
   "beforeMultipleInsert",
   "afterMultipleInsert",
   "beforeMultipleRemove",
@@ -1145,34 +1246,26 @@ var SINGLE_OR_ARRAY_COMPONENTS = [
   "afterMultipleUpdate"
 ];
 async function runSingleHook(hooks, orama, id, doc) {
-  for (let i = 0; i < hooks.length; i++) {
+  const hooksLength = hooks.length;
+  for (let i = 0; i < hooksLength; i++) {
     await hooks[i](orama, id, doc);
   }
 }
+async function runAfterSearch(hooks, db, params, language, results) {
+  const hooksLength = hooks.length;
+  for (let i = 0; i < hooksLength; i++) {
+    await hooks[i](db, params, language, results);
+  }
+}
 
-// ../../node_modules/.pnpm/@orama+orama@1.0.0-beta.16/node_modules/@orama/orama/dist/trees/avl.js
+// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/trees/avl.js
 var BALANCE_STATE = {
-  UNBALANCED_RIGHT: 1,
-  SLIGHTLY_UNBALANCED_RIGHT: 2,
-  BALANCED: 3,
-  SLIGHTLY_UNBALANCED_LEFT: 4,
-  UNBALANCED_LEFT: 5
+  UNBALANCED_RIGHT: -2,
+  SLIGHTLY_UNBALANCED_RIGHT: -1,
+  BALANCED: 0,
+  SLIGHTLY_UNBALANCED_LEFT: 1,
+  UNBALANCED_LEFT: 2
 };
-function getBalanceFactor(node) {
-  const heightDifference = getHeight(node.left) - getHeight(node.right);
-  switch (heightDifference) {
-    case -2:
-      return BALANCE_STATE.UNBALANCED_RIGHT;
-    case -1:
-      return BALANCE_STATE.SLIGHTLY_UNBALANCED_RIGHT;
-    case 1:
-      return BALANCE_STATE.SLIGHTLY_UNBALANCED_LEFT;
-    case 2:
-      return BALANCE_STATE.UNBALANCED_LEFT;
-    default:
-      return BALANCE_STATE.BALANCED;
-  }
-}
 function getHeight(node) {
   return node ? node.height : -1;
 }
@@ -1192,9 +1285,6 @@ function rotateRight(node) {
   left.height = Math.max(getHeight(left.left), getHeight(left.right)) + 1;
   return left;
 }
-function findMin(node) {
-  return node.left ? findMin(node.left) : node;
-}
 function rangeSearch(node, min, max) {
   if (!node) {
     return [];
@@ -1260,16 +1350,16 @@ function lessThan(node, key, inclusive = false) {
   return result;
 }
 function getNodeByKey(node, key) {
-  if (!node) {
-    return null;
-  }
-  if (node.key === key) {
-    return node;
-  }
-  if (key < node.key) {
-    return node.left ? getNodeByKey(node.left, key) : null;
+  while (node !== null) {
+    if (key < node.key) {
+      node = node.left;
+    } else if (key > node.key) {
+      node = node.right;
+    } else {
+      return node;
+    }
   }
-  return node.right ? getNodeByKey(node.right, key) : null;
+  return null;
 }
 function create2(key, value) {
   return {
@@ -1280,93 +1370,124 @@ function create2(key, value) {
     height: 0
   };
 }
-function insert(node, key, value) {
-  if (!node) {
-    return create2(key, value);
+function insert(root, key, value) {
+  let parent = null;
+  let current = root;
+  while (current !== null) {
+    parent = current;
+    if (key < current.key) {
+      current = current.left;
+    } else if (key > current.key) {
+      current = current.right;
+    } else {
+      current.value = current.value.concat(value);
+      return root;
+    }
   }
-  if (key < node.key) {
-    node.left = insert(node.left, key, value);
-  } else if (key > node.key) {
-    node.right = insert(node.right, key, value);
+  const newNode = create2(key, value);
+  if (!parent) {
+    root = newNode;
+  } else if (key < parent.key) {
+    parent.left = newNode;
   } else {
-    node.value = node.value.concat(value);
-    return node;
+    parent.right = newNode;
   }
-  const balanceFactor = getBalanceFactor(node);
-  if (balanceFactor === BALANCE_STATE.UNBALANCED_LEFT) {
-    if (key < node.left.key) {
-      node = rotateRight(node);
-    } else {
-      node.left = rotateLeft(node.left);
-      node = rotateRight(node);
+  current = newNode;
+  while (parent) {
+    const balanceFactor = getHeight(parent.left) - getHeight(parent.right);
+    if (balanceFactor === BALANCE_STATE.UNBALANCED_LEFT) {
+      if (key > parent.left.key) {
+        parent.left = rotateLeft(parent.left);
+      }
+      parent = rotateRight(parent);
     }
+    if (balanceFactor === BALANCE_STATE.UNBALANCED_RIGHT) {
+      if (key < parent.right.key) {
+        parent.right = rotateRight(parent.right);
+      }
+      parent = rotateLeft(parent);
+    }
+    if (parent === root) {
+      break;
+    }
+    current = parent;
+    parent = getNodeParent(root, current.key);
   }
-  if (balanceFactor === BALANCE_STATE.UNBALANCED_RIGHT) {
-    if (key > node.right.key) {
-      node = rotateLeft(node);
+  return root;
+}
+function getNodeParent(root, key) {
+  let current = root;
+  let parent = null;
+  while (current !== null) {
+    if (key < current.key) {
+      parent = current;
+      current = current.left;
+    } else if (key > current.key) {
+      parent = current;
+      current = current.right;
     } else {
-      node.right = rotateRight(node.right);
-      node = rotateLeft(node);
+      break;
     }
   }
-  return node;
+  return parent;
 }
-function find(node, key) {
+function find(root, key) {
+  const node = getNodeByKey(root, key);
   if (!node) {
     return null;
   }
-  if (node.key === key) {
-    return node.value;
-  }
-  if (key < node.key) {
-    return node.left ? find(node.left, key) : null;
-  }
-  return node.right ? find(node.right, key) : null;
+  return node.value;
 }
-function remove2(node, key) {
+function remove2(root, key) {
+  let node = root;
+  let parentNode = null;
+  while (node && node.key !== key) {
+    parentNode = node;
+    if (key < node.key) {
+      node = node.left;
+    } else {
+      node = node.right;
+    }
+  }
   if (!node) {
     return null;
   }
-  if (key < node.key) {
-    node.left = remove2(node.left, key);
-  } else if (key > node.key) {
-    node.right = remove2(node.right, key);
-  } else {
-    if (!node.left && !node.right) {
-      return null;
-    }
-    if (!node.left) {
-      return node.right;
-    }
-    if (!node.right) {
-      return node.left;
-    }
-    const temp = findMin(node.right);
-    node.key = temp.key;
-    node.right = remove2(node.right, temp.key);
-  }
-  const balanceFactor = getBalanceFactor(node);
-  const leftNode = node.left;
-  const rightNode = node.right;
-  if (balanceFactor === BALANCE_STATE.UNBALANCED_LEFT) {
-    if (getBalanceFactor(leftNode) === BALANCE_STATE.BALANCED || getBalanceFactor(leftNode) === BALANCE_STATE.SLIGHTLY_UNBALANCED_LEFT) {
-      return rotateRight(node);
+  if (!node.left && !node.right) {
+    if (!parentNode) {
+      root = null;
+    } else {
+      if (parentNode.left === node) {
+        parentNode.left = null;
+      } else {
+        parentNode.right = null;
+      }
     }
-    if (getBalanceFactor(leftNode) === BALANCE_STATE.SLIGHTLY_UNBALANCED_RIGHT) {
-      node.left = rotateLeft(leftNode);
-      return rotateRight(node);
+  } else if (node.left && node.right) {
+    let minValueNode = node.right;
+    let minValueParent = node;
+    while (minValueNode.left) {
+      minValueParent = minValueNode;
+      minValueNode = minValueNode.left;
     }
-  }
-  if (balanceFactor === BALANCE_STATE.UNBALANCED_RIGHT) {
-    if (getBalanceFactor(rightNode) === BALANCE_STATE.BALANCED || getBalanceFactor(rightNode) === BALANCE_STATE.SLIGHTLY_UNBALANCED_RIGHT) {
-      return rotateLeft(node);
+    node.key = minValueNode.key;
+    if (minValueParent === node) {
+      minValueParent.right = minValueNode.right;
+    } else {
+      minValueParent.left = minValueNode.right;
     }
-    if (getBalanceFactor(rightNode) === BALANCE_STATE.SLIGHTLY_UNBALANCED_LEFT) {
-      node.right = rotateRight(rightNode);
-      return rotateLeft(node);
+  } else {
+    const childNode = node.left ? node.left : node.right;
+    if (!parentNode) {
+      root = childNode;
+    } else {
+      if (parentNode.left === node) {
+        parentNode.left = childNode;
+      } else {
+        parentNode.right = childNode;
+      }
     }
   }
-  return node;
+  return root;
 }
 function removeDocument(root, id, key) {
   const node = getNodeByKey(root, key);
@@ -1377,7 +1498,7 @@ function removeDocument(root, id, key) {
   node.value.splice(node.value.indexOf(id), 1);
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.0.0-beta.16/node_modules/@orama/orama/dist/components/levenshtein.js
+// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/components/levenshtein.js
 function _boundedLevenshtein(a, b, tolerance) {
   if (a === b) {
     return 0;
@@ -1466,19 +1587,27 @@ function syncBoundedLevenshtein(a, b, tolerance) {
   };
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.0.0-beta.16/node_modules/@orama/orama/dist/trees/radix.js
-function serialize() {
-  const { word, subWord, children, docs, end } = this;
-  return {
-    word,
-    subWord,
-    children,
-    docs,
-    end
-  };
-}
+// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/trees/radix.js
+var Node = class {
+  constructor(key, subWord, end) {
+    this.key = key;
+    this.subWord = subWord;
+    this.end = end;
+  }
+  children = {};
+  docs = [];
+  word = "";
+  toJSON() {
+    return {
+      word: this.word,
+      subWord: this.subWord,
+      children: this.children,
+      docs: this.docs,
+      end: this.end
+    };
+  }
+};
 function updateParent(node, parent) {
-  node.parent = parent.id;
   node.word = parent.word + node.subWord;
 }
 function addDocument(node, docID) {
@@ -1534,20 +1663,7 @@ function getCommonPrefix(a, b) {
   return commonPrefix;
 }
 function create3(end = false, subWord = "", key = "") {
-  const node = {
-    id: syncUniqueId(),
-    key,
-    subWord,
-    parent: null,
-    children: {},
-    docs: [],
-    end,
-    word: ""
-  };
-  Object.defineProperty(node, "toJSON", {
-    value: serialize
-  });
-  return node;
+  return new Node(key, subWord, end);
 }
 function insert2(root, word, docId) {
   for (let i = 0; i < word.length; i++) {
@@ -1559,12 +1675,12 @@ function insert2(root, word, docId) {
       const edgeLabelLength = edgeLabel.length;
       const commonPrefix = getCommonPrefix(edgeLabel, wordAtIndex);
       const commonPrefixLength = commonPrefix.length;
-      const edgeLabelAtCommonPrefix = edgeLabel[commonPrefixLength];
       if (edgeLabel === wordAtIndex) {
         addDocument(rootChildCurrentChar, docId);
         rootChildCurrentChar.end = true;
         return;
       }
+      const edgeLabelAtCommonPrefix = edgeLabel[commonPrefixLength];
       if (commonPrefixLength < edgeLabelLength && commonPrefixLength === wordAtIndex.length) {
         const newNode = create3(true, wordAtIndex, currentCharacter);
         newNode.children[edgeLabelAtCommonPrefix] = rootChildCurrentChar;
@@ -1649,12 +1765,13 @@ function removeDocumentByWord(root, term, docID, exact = true) {
   return true;
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.0.0-beta.16/node_modules/@orama/orama/dist/components/algorithms.js
-function prioritizeTokenScores(arrays, boost, threshold = 1) {
+// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/components/algorithms.js
+function prioritizeTokenScores(arrays, boost, threshold = 1, keywordsCount) {
   if (boost === 0) {
     throw createError("INVALID_BOOST_VALUE");
   }
-  const tokenMap = {};
+  const tokenScoresMap = /* @__PURE__ */ new Map();
+  const tokenKeywordsCountMap = /* @__PURE__ */ new Map();
   const mapsLength = arrays.length;
   for (let i = 0; i < mapsLength; i++) {
     const arr = arrays[i];
@@ -1662,22 +1779,48 @@ function prioritizeTokenScores(arrays, boost, threshold = 1) {
     for (let j = 0; j < entriesLength; j++) {
       const [token, score] = arr[j];
       const boostScore = score * boost;
-      if (token in tokenMap) {
-        tokenMap[token] *= 1.5 + boostScore;
+      const oldScore = tokenScoresMap.get(token);
+      if (oldScore !== void 0) {
+        tokenScoresMap.set(token, oldScore * 1.5 + boostScore);
+        tokenKeywordsCountMap.set(token, tokenKeywordsCountMap.get(token) + 1);
       } else {
-        tokenMap[token] = boostScore;
+        tokenScoresMap.set(token, boostScore);
+        tokenKeywordsCountMap.set(token, 1);
       }
     }
   }
-  const results = Object.entries(tokenMap).sort((a, b) => b[1] - a[1]);
+  const tokenScores = [];
+  for (const tokenScoreEntry of tokenScoresMap.entries()) {
+    tokenScores.push(tokenScoreEntry);
+  }
+  const results = tokenScores.sort((a, b) => b[1] - a[1]);
   if (threshold === 1) {
     return results;
   }
+  const allResults = results.length;
+  const tokenKeywordsCount = [];
+  for (const tokenKeywordsCountEntry of tokenKeywordsCountMap.entries()) {
+    tokenKeywordsCount.push(tokenKeywordsCountEntry);
+  }
+  const keywordsPerToken = tokenKeywordsCount.sort((a, b) => b[1] - a[1]);
+  let lastTokenWithAllKeywords = void 0;
+  for (let i = 0; i < allResults; i++) {
+    if (keywordsPerToken[i][1] === keywordsCount) {
+      lastTokenWithAllKeywords = i;
+    } else {
+      break;
+    }
+  }
+  if (typeof lastTokenWithAllKeywords === "undefined") {
+    if (threshold === 0) {
+      return [];
+    }
+    lastTokenWithAllKeywords = 0;
+  }
   if (threshold === 0) {
-    const shortestArrayLength = Math.min(...arrays.map((arr) => arr.length));
-    return results.slice(0, shortestArrayLength);
+    return results.slice(0, lastTokenWithAllKeywords + 1);
   }
-  const thresholdLength = Math.ceil(threshold * 100 * results.length / 100);
+  const thresholdLength = lastTokenWithAllKeywords + Math.ceil(threshold * 100 * (results.length - lastTokenWithAllKeywords) / 100);
   return results.slice(0, results.length + thresholdLength);
 }
 function BM25(tf, matchingCount, docsCount, fieldLength, averageFieldLength, BM25Params) {
@@ -1686,12 +1829,13 @@ function BM25(tf, matchingCount, docsCount, fieldLength, averageFieldLength, BM2
   return idf * (d + tf * (k + 1)) / (tf + k * (1 - b + b * fieldLength / averageFieldLength));
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.0.0-beta.16/node_modules/@orama/orama/dist/components/index.js
+// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/components/index.js
 async function insertDocumentScoreParameters(index, prop, id, tokens, docsCount) {
   var _a2;
+  const internalId = getInternalDocumentId(index.sharedInternalDocumentStore, id);
   index.avgFieldLength[prop] = (((_a2 = index.avgFieldLength[prop]) != null ? _a2 : 0) * (docsCount - 1) + tokens.length) / docsCount;
-  index.fieldLengths[prop][id] = tokens.length;
-  index.frequencies[prop][id] = {};
+  index.fieldLengths[prop][internalId] = tokens.length;
+  index.frequencies[prop][internalId] = {};
 }
 async function insertTokenScoreParameters(index, prop, id, tokens, token) {
   var _a2;
@@ -1701,51 +1845,54 @@ async function insertTokenScoreParameters(index, prop, id, tokens, token) {
       tokenFrequency++;
     }
   }
+  const internalId = getInternalDocumentId(index.sharedInternalDocumentStore, id);
   const tf = tokenFrequency / tokens.length;
-  index.frequencies[prop][id][token] = tf;
-  if (!(token in index.tokenOccurrencies[prop])) {
-    index.tokenOccurrencies[prop][token] = 0;
+  index.frequencies[prop][internalId][token] = tf;
+  if (!(token in index.tokenOccurrences[prop])) {
+    index.tokenOccurrences[prop][token] = 0;
   }
-  index.tokenOccurrencies[prop][token] = ((_a2 = index.tokenOccurrencies[prop][token]) != null ? _a2 : 0) + 1;
+  index.tokenOccurrences[prop][token] = ((_a2 = index.tokenOccurrences[prop][token]) != null ? _a2 : 0) + 1;
 }
 async function removeDocumentScoreParameters(index, prop, id, docsCount) {
-  index.avgFieldLength[prop] = (index.avgFieldLength[prop] * docsCount - index.fieldLengths[prop][id]) / (docsCount - 1);
-  index.fieldLengths[prop][id] = void 0;
-  index.frequencies[prop][id] = void 0;
+  const internalId = getInternalDocumentId(index.sharedInternalDocumentStore, id);
+  index.avgFieldLength[prop] = (index.avgFieldLength[prop] * docsCount - index.fieldLengths[prop][internalId]) / (docsCount - 1);
+  index.fieldLengths[prop][internalId] = void 0;
+  index.frequencies[prop][internalId] = void 0;
 }
 async function removeTokenScoreParameters(index, prop, token) {
-  index.tokenOccurrencies[prop][token]--;
+  index.tokenOccurrences[prop][token]--;
 }
 async function calculateResultScores(context, index, prop, term, ids) {
   var _a2, _b;
   const documentIDs = Array.from(ids);
   const avgFieldLength = index.avgFieldLength[prop];
   const fieldLengths = index.fieldLengths[prop];
-  const oramaOccurrencies = index.tokenOccurrencies[prop];
+  const oramaOccurrences = index.tokenOccurrences[prop];
   const oramaFrequencies = index.frequencies[prop];
-  const termOccurrencies = typeof oramaOccurrencies[term] === "number" ? (_a2 = oramaOccurrencies[term]) != null ? _a2 : 0 : 0;
+  const termOccurrences = typeof oramaOccurrences[term] === "number" ? (_a2 = oramaOccurrences[term]) != null ? _a2 : 0 : 0;
   const scoreList = [];
   const documentIDsLength = documentIDs.length;
   for (let k = 0; k < documentIDsLength; k++) {
-    var _oramaFrequencies_id;
-    const id = documentIDs[k];
-    const tf = (_b = oramaFrequencies === null || oramaFrequencies === void 0 ? void 0 : (_oramaFrequencies_id = oramaFrequencies[id]) === null || _oramaFrequencies_id === void 0 ? void 0 : _oramaFrequencies_id[term]) != null ? _b : 0;
-    const bm25 = BM25(tf, termOccurrencies, context.docsCount, fieldLengths[id], avgFieldLength, context.params.relevance);
+    var _oramaFrequencies_internalId;
+    const internalId = getInternalDocumentId(index.sharedInternalDocumentStore, documentIDs[k]);
+    const tf = (_b = oramaFrequencies === null || oramaFrequencies === void 0 ? void 0 : (_oramaFrequencies_internalId = oramaFrequencies[internalId]) === null || _oramaFrequencies_internalId === void 0 ? void 0 : _oramaFrequencies_internalId[term]) != null ? _b : 0;
+    const bm25 = BM25(tf, termOccurrences, context.docsCount, fieldLengths[internalId], avgFieldLength, context.params.relevance);
     scoreList.push([
-      id,
+      internalId,
       bm25
     ]);
   }
   return scoreList;
 }
-async function create4(orama, schema, index, prefix = "") {
+async function create4(orama, sharedInternalDocumentStore, schema, index, prefix = "") {
   if (!index) {
     index = {
+      sharedInternalDocumentStore,
       indexes: {},
       searchableProperties: [],
       searchablePropertiesWithTypes: {},
       frequencies: {},
-      tokenOccurrencies: {},
+      tokenOccurrences: {},
       avgFieldLength: {},
       fieldLengths: {}
     };
@@ -1754,71 +1901,110 @@ async function create4(orama, schema, index, prefix = "") {
     const typeActualType = typeof type;
     const path = `${prefix}${prefix ? "." : ""}${prop}`;
     if (typeActualType === "object" && !Array.isArray(type)) {
-      create4(orama, type, index, path);
+      create4(orama, sharedInternalDocumentStore, type, index, path);
       continue;
     }
     switch (type) {
       case "boolean":
+      case "boolean[]":
         index.indexes[path] = {
           true: [],
           false: []
         };
         break;
       case "number":
+      case "number[]":
         index.indexes[path] = create2(0, []);
         break;
       case "string":
+      case "string[]":
         index.indexes[path] = create3();
         index.avgFieldLength[path] = 0;
         index.frequencies[path] = {};
-        index.tokenOccurrencies[path] = {};
+        index.tokenOccurrences[path] = {};
         index.fieldLengths[path] = {};
         break;
       default:
-        throw createError("INVALID_SCHEMA_TYPE", Array.isArray(type) ? "array" : typeActualType);
+        throw createError("INVALID_SCHEMA_TYPE", Array.isArray(type) ? "array" : type, path);
     }
     index.searchableProperties.push(path);
     index.searchablePropertiesWithTypes[path] = type;
   }
   return index;
 }
-async function insert3(implementation, index, prop, id, value, language, tokenizer, docsCount) {
-  if (typeof value === "number") {
-    insert(index.indexes[prop], value, [
-      id
-    ]);
-    return;
-  } else if (typeof value === "boolean") {
-    index.indexes[prop][value ? "true" : "false"].push(id);
-    return;
+async function insertScalar(implementation, index, prop, id, value, schemaType, language, tokenizer, docsCount) {
+  const internalId = getInternalDocumentId(index.sharedInternalDocumentStore, id);
+  switch (schemaType) {
+    case "boolean": {
+      const booleanIndex = index.indexes[prop];
+      booleanIndex[value ? "true" : "false"].push(internalId);
+      break;
+    }
+    case "number":
+      insert(index.indexes[prop], value, [
+        internalId
+      ]);
+      break;
+    case "string": {
+      const tokens = await tokenizer.tokenize(value, language, prop);
+      await implementation.insertDocumentScoreParameters(index, prop, internalId, tokens, docsCount);
+      for (const token of tokens) {
+        await implementation.insertTokenScoreParameters(index, prop, internalId, tokens, token);
+        insert2(index.indexes[prop], token, internalId);
+      }
+      break;
+    }
   }
-  const tokens = await tokenizer.tokenize(value, language, prop);
-  await implementation.insertDocumentScoreParameters(index, prop, id, tokens, docsCount);
-  for (const token of tokens) {
-    await implementation.insertTokenScoreParameters(index, prop, id, tokens, token);
-    insert2(index.indexes[prop], token, id);
+}
+async function insert3(implementation, index, prop, id, value, schemaType, language, tokenizer, docsCount) {
+  if (!isArrayType(schemaType)) {
+    return insertScalar(implementation, index, prop, id, value, schemaType, language, tokenizer, docsCount);
+  }
+  const innerSchemaType = getInnerType(schemaType);
+  const elements = value;
+  const elementsLength = elements.length;
+  for (let i = 0; i < elementsLength; i++) {
+    await insertScalar(implementation, index, prop, id, elements[i], innerSchemaType, language, tokenizer, docsCount);
   }
 }
-async function remove3(implementation, index, prop, id, value, language, tokenizer, docsCount) {
-  if (typeof value === "number") {
-    removeDocument(index.indexes[prop], id, value);
-    return true;
-  } else if (typeof value === "boolean") {
-    const booleanKey = value ? "true" : "false";
-    const position = index.indexes[prop][booleanKey].indexOf(id);
-    index.indexes[prop][value ? "true" : "false"].splice(position, 1);
-    return true;
+async function removeScalar(implementation, index, prop, id, value, schemaType, language, tokenizer, docsCount) {
+  const internalId = getInternalDocumentId(index.sharedInternalDocumentStore, id);
+  switch (schemaType) {
+    case "number": {
+      removeDocument(index.indexes[prop], internalId, value);
+      return true;
+    }
+    case "boolean": {
+      const booleanKey = value ? "true" : "false";
+      const position = index.indexes[prop][booleanKey].indexOf(internalId);
+      index.indexes[prop][value ? "true" : "false"].splice(position, 1);
+      return true;
+    }
+    case "string": {
+      const tokens = await tokenizer.tokenize(value, language, prop);
+      await implementation.removeDocumentScoreParameters(index, prop, id, docsCount);
+      for (const token of tokens) {
+        await implementation.removeTokenScoreParameters(index, prop, token);
+        removeDocumentByWord(index.indexes[prop], token, internalId);
+      }
+      return true;
+    }
+  }
+}
+async function remove3(implementation, index, prop, id, value, schemaType, language, tokenizer, docsCount) {
+  if (!isArrayType(schemaType)) {
+    return removeScalar(implementation, index, prop, id, value, schemaType, language, tokenizer, docsCount);
   }
-  const tokens = await tokenizer.tokenize(value, language, prop);
-  await implementation.removeDocumentScoreParameters(index, prop, id, docsCount);
-  for (const token of tokens) {
-    await implementation.removeTokenScoreParameters(index, prop, token);
-    removeDocumentByWord(index.indexes[prop], token, id);
+  const innerSchemaType = getInnerType(schemaType);
+  const elements = value;
+  const elementsLength = elements.length;
+  for (let i = 0; i < elementsLength; i++) {
+    await removeScalar(implementation, index, prop, id, elements[i], innerSchemaType, language, tokenizer, docsCount);
   }
   return true;
 }
 async function search(context, index, prop, term) {
-  if (!(prop in index.tokenOccurrencies)) {
+  if (!(prop in index.tokenOccurrences)) {
     return [];
   }
   const rootNode = index.indexes[prop];
@@ -1846,12 +2032,18 @@ async function searchByWhereClause(context, index, filters) {
     const operation = filters[param];
     if (typeof operation === "boolean") {
       const idx = index.indexes[param];
+      if (typeof idx === "undefined") {
+        throw createError("UNKNOWN_FILTER_PROPERTY", param);
+      }
       const filteredIDs = idx[operation.toString()];
       filtersMap[param].push(...filteredIDs);
       continue;
     }
     if (typeof operation === "string" || Array.isArray(operation)) {
       const idx = index.indexes[param];
+      if (typeof idx === "undefined") {
+        throw createError("UNKNOWN_FILTER_PROPERTY", param);
+      }
       for (const raw of [
         operation
       ].flat()) {
@@ -1871,6 +2063,9 @@ async function searchByWhereClause(context, index, filters) {
     const operationOpt = operationKeys[0];
     const operationValue = operation[operationOpt];
     const AVLNode = index.indexes[param];
+    if (typeof AVLNode === "undefined") {
+      throw createError("UNKNOWN_FILTER_PROPERTY", param);
+    }
     switch (operationOpt) {
       case "gt": {
         const filteredIDs = greaterThan(AVLNode, operationValue, false);
@@ -1913,26 +2108,45 @@ async function getSearchableProperties(index) {
 async function getSearchablePropertiesWithTypes(index) {
   return index.searchablePropertiesWithTypes;
 }
-async function load2(raw) {
-  const { indexes, searchableProperties, searchablePropertiesWithTypes, frequencies, tokenOccurrencies, avgFieldLength, fieldLengths } = raw;
+function loadNode(node) {
+  const convertedNode = create3(node.end, node.subWord, node.key);
+  convertedNode.docs = node.docs;
+  convertedNode.word = node.word;
+  for (const childrenKey of Object.keys(node.children)) {
+    convertedNode.children[childrenKey] = loadNode(node.children[childrenKey]);
+  }
+  return convertedNode;
+}
+async function load3(sharedInternalDocumentStore, raw) {
+  const { indexes: rawIndexes, searchableProperties, searchablePropertiesWithTypes, frequencies, tokenOccurrences, avgFieldLength, fieldLengths } = raw;
+  const indexes = {};
+  for (const prop of Object.keys(rawIndexes)) {
+    const value = rawIndexes[prop];
+    if (!("word" in value)) {
+      indexes[prop] = value;
+      continue;
+    }
+    indexes[prop] = loadNode(value);
+  }
   return {
+    sharedInternalDocumentStore,
     indexes,
     searchableProperties,
     searchablePropertiesWithTypes,
     frequencies,
-    tokenOccurrencies,
+    tokenOccurrences,
     avgFieldLength,
     fieldLengths
   };
 }
-async function save2(index) {
-  const { indexes, searchableProperties, searchablePropertiesWithTypes, frequencies, tokenOccurrencies, avgFieldLength, fieldLengths } = index;
+async function save3(index) {
+  const { indexes, searchableProperties, searchablePropertiesWithTypes, frequencies, tokenOccurrences, avgFieldLength, fieldLengths } = index;
   return {
     indexes,
     searchableProperties,
     searchablePropertiesWithTypes,
     frequencies,
-    tokenOccurrencies,
+    tokenOccurrences,
     avgFieldLength,
     fieldLengths
   };
@@ -1951,12 +2165,12 @@ async function createIndex() {
     searchByWhereClause,
     getSearchableProperties,
     getSearchablePropertiesWithTypes,
-    load: load2,
-    save: save2
+    load: load3,
+    save: save3
   };
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.0.0-beta.16/node_modules/@orama/orama/dist/components/tokenizer/diacritics.js
+// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/components/tokenizer/diacritics.js
 var DIACRITICS_CHARCODE_START = 192;
 var DIACRITICS_CHARCODE_END = 383;
 var CHARCODE_REPLACE_MAPPING = [
@@ -2166,2317 +2380,7 @@ function replaceDiacritics(str) {
   return String.fromCharCode(...stringCharCode);
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.0.0-beta.16/node_modules/@orama/orama/dist/components/tokenizer/stop-words/en.js
-var en = [
-  "i",
-  "me",
-  "my",
-  "myself",
-  "we",
-  "us",
-  "our",
-  "ours",
-  "ourselves",
-  "you",
-  "your",
-  "yours",
-  "yourself",
-  "yourselves",
-  "he",
-  "him",
-  "his",
-  "himself",
-  "she",
-  "her",
-  "hers",
-  "herself",
-  "it",
-  "its",
-  "itself",
-  "they",
-  "them",
-  "their",
-  "theirs",
-  "themselves",
-  "what",
-  "which",
-  "who",
-  "whom",
-  "this",
-  "that",
-  "these",
-  "those",
-  "am",
-  "is",
-  "are",
-  "was",
-  "were",
-  "be",
-  "been",
-  "being",
-  "have",
-  "has",
-  "had",
-  "having",
-  "do",
-  "does",
-  "did",
-  "doing",
-  "will",
-  "would",
-  "shall",
-  "should",
-  "can",
-  "could",
-  "may",
-  "might",
-  "must",
-  "ought",
-  "i'm",
-  "you're",
-  "he's",
-  "she's",
-  "it's",
-  "we're",
-  "they're",
-  "i've",
-  "you've",
-  "we've",
-  "they've",
-  "i'd",
-  "you'd",
-  "he'd",
-  "she'd",
-  "we'd",
-  "they'd",
-  "i'll",
-  "you'll",
-  "he'll",
-  "she'll",
-  "we'll",
-  "they'll",
-  "isn't",
-  "aren't",
-  "wasn't",
-  "weren't",
-  "hasn't",
-  "haven't",
-  "hadn't",
-  "doesn't",
-  "don't",
-  "didn't",
-  "won't",
-  "wouldn't",
-  "shan't",
-  "shouldn't",
-  "can't",
-  "cannot",
-  "couldn't",
-  "mustn't",
-  "let's",
-  "that's",
-  "who's",
-  "what's",
-  "here's",
-  "there's",
-  "when's",
-  "where's",
-  "why's",
-  "how's",
-  "an",
-  "the",
-  "and",
-  "but",
-  "if",
-  "or",
-  "because",
-  "as",
-  "until",
-  "while",
-  "of",
-  "at",
-  "by",
-  "for",
-  "with",
-  "about",
-  "against",
-  "between",
-  "into",
-  "through",
-  "during",
-  "before",
-  "after",
-  "above",
-  "below",
-  "to",
-  "from",
-  "up",
-  "down",
-  "in",
-  "out",
-  "on",
-  "off",
-  "over",
-  "under",
-  "again",
-  "further",
-  "then",
-  "once",
-  "here",
-  "there",
-  "when",
-  "where",
-  "why",
-  "how",
-  "all",
-  "any",
-  "both",
-  "each",
-  "few",
-  "more",
-  "most",
-  "other",
-  "some",
-  "such",
-  "no",
-  "nor",
-  "not",
-  "only",
-  "own",
-  "same",
-  "so",
-  "than",
-  "too",
-  "very"
-];
-
-// ../../node_modules/.pnpm/@orama+orama@1.0.0-beta.16/node_modules/@orama/orama/dist/components/tokenizer/stop-words/it.js
-var it = [
-  "ad",
-  "al",
-  "allo",
-  "ai",
-  "agli",
-  "all",
-  "agl",
-  "alla",
-  "alle",
-  "con",
-  "col",
-  "coi",
-  "da",
-  "dal",
-  "dallo",
-  "dai",
-  "dagli",
-  "dall",
-  "dagl",
-  "dalla",
-  "dalle",
-  "di",
-  "del",
-  "dello",
-  "dei",
-  "degli",
-  "dell",
-  "degl",
-  "della",
-  "delle",
-  "in",
-  "nel",
-  "nello",
-  "nei",
-  "negli",
-  "nell",
-  "negl",
-  "nella",
-  "nelle",
-  "su",
-  "sul",
-  "sullo",
-  "sui",
-  "sugli",
-  "sull",
-  "sugl",
-  "sulla",
-  "sulle",
-  "per",
-  "tra",
-  "contro",
-  "io",
-  "tu",
-  "lui",
-  "lei",
-  "noi",
-  "voi",
-  "loro",
-  "mio",
-  "mia",
-  "miei",
-  "mie",
-  "tuo",
-  "tua",
-  "tuoi",
-  "tue",
-  "suo",
-  "sua",
-  "suoi",
-  "sue",
-  "nostro",
-  "nostra",
-  "nostri",
-  "nostre",
-  "vostro",
-  "vostra",
-  "vostri",
-  "vostre",
-  "mi",
-  "ti",
-  "ci",
-  "vi",
-  "lo",
-  "la",
-  "li",
-  "le",
-  "gli",
-  "ne",
-  "il",
-  "un",
-  "uno",
-  "una",
-  "ma",
-  "ed",
-  "se",
-  "perch\xE9",
-  "anche",
-  "come",
-  "dov",
-  "dove",
-  "che",
-  "chi",
-  "cui",
-  "non",
-  "pi\xF9",
-  "quale",
-  "quanto",
-  "quanti",
-  "quanta",
-  "quante",
-  "quello",
-  "quelli",
-  "quella",
-  "quelle",
-  "questo",
-  "questi",
-  "questa",
-  "queste",
-  "si",
-  "tutto",
-  "tutti",
-  "a",
-  "c",
-  "e",
-  "i",
-  "l",
-  "o",
-  "ho",
-  "hai",
-  "ha",
-  "abbiamo",
-  "avete",
-  "hanno",
-  "abbia",
-  "abbiate",
-  "abbiano",
-  "avr\xF2",
-  "avrai",
-  "avr\xE0",
-  "avremo",
-  "avrete",
-  "avranno",
-  "avrei",
-  "avresti",
-  "avrebbe",
-  "avremmo",
-  "avreste",
-  "avrebbero",
-  "avevo",
-  "avevi",
-  "aveva",
-  "avevamo",
-  "avevate",
-  "avevano",
-  "ebbi",
-  "avesti",
-  "ebbe",
-  "avemmo",
-  "aveste",
-  "ebbero",
-  "avessi",
-  "avesse",
-  "avessimo",
-  "avessero",
-  "avendo",
-  "avuto",
-  "avuta",
-  "avuti",
-  "avute",
-  "sono",
-  "sei",
-  "\xE8",
-  "siamo",
-  "siete",
-  "sia",
-  "siate",
-  "siano",
-  "sar\xF2",
-  "sarai",
-  "sar\xE0",
-  "saremo",
-  "sarete",
-  "saranno",
-  "sarei",
-  "saresti",
-  "sarebbe",
-  "saremmo",
-  "sareste",
-  "sarebbero",
-  "ero",
-  "eri",
-  "era",
-  "eravamo",
-  "eravate",
-  "erano",
-  "fui",
-  "fosti",
-  "fu",
-  "fummo",
-  "foste",
-  "furono",
-  "fossi",
-  "fosse",
-  "fossimo",
-  "fossero",
-  "essendo",
-  "faccio",
-  "fai",
-  "facciamo",
-  "fanno",
-  "faccia",
-  "facciate",
-  "facciano",
-  "far\xF2",
-  "farai",
-  "far\xE0",
-  "faremo",
-  "farete",
-  "faranno",
-  "farei",
-  "faresti",
-  "farebbe",
-  "faremmo",
-  "fareste",
-  "farebbero",
-  "facevo",
-  "facevi",
-  "faceva",
-  "facevamo",
-  "facevate",
-  "facevano",
-  "feci",
-  "facesti",
-  "fece",
-  "facemmo",
-  "faceste",
-  "fecero",
-  "facessi",
-  "facesse",
-  "facessimo",
-  "facessero",
-  "facendo",
-  "sto",
-  "stai",
-  "sta",
-  "stiamo",
-  "stanno",
-  "stia",
-  "stiate",
-  "stiano",
-  "star\xF2",
-  "starai",
-  "star\xE0",
-  "staremo",
-  "starete",
-  "staranno",
-  "starei",
-  "staresti",
-  "starebbe",
-  "staremmo",
-  "stareste",
-  "starebbero",
-  "stavo",
-  "stavi",
-  "stava",
-  "stavamo",
-  "stavate",
-  "stavano",
-  "stetti",
-  "stesti",
-  "stette",
-  "stemmo",
-  "steste",
-  "stettero",
-  "stessi",
-  "stesse",
-  "stessimo",
-  "stessero",
-  "stando"
-];
-
-// ../../node_modules/.pnpm/@orama+orama@1.0.0-beta.16/node_modules/@orama/orama/dist/components/tokenizer/stop-words/fr.js
-var fr = [
-  "au",
-  "aux",
-  "avec",
-  "ce",
-  "ces",
-  "dans",
-  "de",
-  "des",
-  "du",
-  "elle",
-  "en",
-  "et",
-  "eux",
-  "il",
-  "je",
-  "la",
-  "le",
-  "leur",
-  "lui",
-  "ma",
-  "mais",
-  "me",
-  "m\xEAme",
-  "mes",
-  "moi",
-  "mon",
-  "ne",
-  "nos",
-  "notre",
-  "nous",
-  "on",
-  "ou",
-  "par",
-  "pas",
-  "pour",
-  "qu",
-  "que",
-  "qui",
-  "sa",
-  "se",
-  "ses",
-  "son",
-  "sur",
-  "ta",
-  "te",
-  "tes",
-  "toi",
-  "ton",
-  "tu",
-  "un",
-  "une",
-  "vos",
-  "votre",
-  "vous",
-  "c",
-  "d",
-  "j",
-  "l",
-  "\xE0",
-  "m",
-  "n",
-  "s",
-  "t",
-  "y",
-  "",
-  "\xE9t\xE9",
-  "\xE9t\xE9e",
-  "\xE9t\xE9es",
-  "\xE9t\xE9s",
-  "\xE9tant",
-  "suis",
-  "es",
-  "est",
-  "sommes",
-  "\xEAtes",
-  "sont",
-  "serai",
-  "seras",
-  "sera",
-  "serons",
-  "serez",
-  "seront",
-  "serais",
-  "serait",
-  "serions",
-  "seriez",
-  "seraient",
-  "\xE9tais",
-  "\xE9tait",
-  "\xE9tions",
-  "\xE9tiez",
-  "\xE9taient",
-  "fus",
-  "fut",
-  "f\xFBmes",
-  "f\xFBtes",
-  "furent",
-  "sois",
-  "soit",
-  "soyons",
-  "soyez",
-  "soient",
-  "fusse",
-  "fusses",
-  "f\xFBt",
-  "fussions",
-  "fussiez",
-  "fussent",
-  "ayant",
-  "eu",
-  "eue",
-  "eues",
-  "eus",
-  "ai",
-  "as",
-  "avons",
-  "avez",
-  "ont",
-  "aurai",
-  "auras",
-  "aura",
-  "aurons",
-  "aurez",
-  "auront",
-  "aurais",
-  "aurait",
-  "aurions",
-  "auriez",
-  "auraient",
-  "avais",
-  "avait",
-  "avions",
-  "aviez",
-  "avaient",
-  "eut",
-  "e\xFBmes",
-  "e\xFBtes",
-  "eurent",
-  "aie",
-  "aies",
-  "ait",
-  "ayons",
-  "ayez",
-  "aient",
-  "eusse",
-  "eusses",
-  "e\xFBt",
-  "eussions",
-  "eussiez",
-  "eussent",
-  "ceci",
-  "cela",
-  "cel\xE0",
-  "cet",
-  "cette",
-  "ici",
-  "ils",
-  "les",
-  "leurs",
-  "quel",
-  "quels",
-  "quelle",
-  "quelles",
-  "sans",
-  "soi"
-];
-
-// ../../node_modules/.pnpm/@orama+orama@1.0.0-beta.16/node_modules/@orama/orama/dist/components/tokenizer/stop-words/es.js
-var es = [
-  "de",
-  "la",
-  "que",
-  "el",
-  "en",
-  "y",
-  "a",
-  "los",
-  "del",
-  "se",
-  "las",
-  "por",
-  "un",
-  "para",
-  "con",
-  "no",
-  "una",
-  "su",
-  "al",
-  "lo",
-  "como",
-  "m\xE1s",
-  "pero",
-  "sus",
-  "le",
-  "ya",
-  "o",
-  "este",
-  "s\xED",
-  "porque",
-  "esta",
-  "entre",
-  "cuando",
-  "muy",
-  "sin",
-  "sobre",
-  "tambi\xE9n",
-  "me",
-  "hasta",
-  "hay",
-  "donde",
-  "quien",
-  "desde",
-  "todo",
-  "nos",
-  "durante",
-  "todos",
-  "uno",
-  "les",
-  "ni",
-  "contra",
-  "otros",
-  "ese",
-  "eso",
-  "ante",
-  "ellos",
-  "e",
-  "esto",
-  "m\xED",
-  "antes",
-  "algunos",
-  "qu\xE9",
-  "unos",
-  "yo",
-  "otro",
-  "otras",
-  "otra",
-  "\xE9l",
-  "tanto",
-  "esa",
-  "estos",
-  "mucho",
-  "quienes",
-  "nada",
-  "muchos",
-  "cual",
-  "poco",
-  "ella",
-  "estar",
-  "estas",
-  "algunas",
-  "algo",
-  "nosotros",
-  "mi",
-  "mis",
-  "t\xFA",
-  "te",
-  "ti",
-  "tu",
-  "tus",
-  "ellas",
-  "nosotras",
-  "vosotros",
-  "vosotras",
-  "os",
-  "m\xEDo",
-  "m\xEDa",
-  "m\xEDos",
-  "m\xEDas",
-  "tuyo",
-  "tuya",
-  "tuyos",
-  "tuyas",
-  "suyo",
-  "suya",
-  "suyos",
-  "suyas",
-  "nuestro",
-  "nuestra",
-  "nuestros",
-  "nuestras",
-  "vuestro",
-  "vuestra",
-  "vuestros",
-  "vuestras",
-  "esos",
-  "esas",
-  "estoy",
-  "est\xE1s",
-  "est\xE1",
-  "estamos",
-  "est\xE1is",
-  "est\xE1n",
-  "est\xE9",
-  "est\xE9s",
-  "estemos",
-  "est\xE9is",
-  "est\xE9n",
-  "estar\xE9",
-  "estar\xE1s",
-  "estar\xE1",
-  "estaremos",
-  "estar\xE9is",
-  "estar\xE1n",
-  "estar\xEDa",
-  "estar\xEDas",
-  "estar\xEDamos",
-  "estar\xEDais",
-  "estar\xEDan",
-  "estaba",
-  "estabas",
-  "est\xE1bamos",
-  "estabais",
-  "estaban",
-  "estuve",
-  "estuviste",
-  "estuvo",
-  "estuvimos",
-  "estuvisteis",
-  "estuvieron",
-  "estuviera",
-  "estuvieras",
-  "estuvi\xE9ramos",
-  "estuvierais",
-  "estuvieran",
-  "estuviese",
-  "estuvieses",
-  "estuvi\xE9semos",
-  "estuvieseis",
-  "estuviesen",
-  "estando",
-  "estado",
-  "estada",
-  "estados",
-  "estadas",
-  "estad",
-  "he",
-  "has",
-  "ha",
-  "hemos",
-  "hab\xE9is",
-  "han",
-  "haya",
-  "hayas",
-  "hayamos",
-  "hay\xE1is",
-  "hayan",
-  "habr\xE9",
-  "habr\xE1s",
-  "habr\xE1",
-  "habremos",
-  "habr\xE9is",
-  "habr\xE1n",
-  "habr\xEDa",
-  "habr\xEDas",
-  "habr\xEDamos",
-  "habr\xEDais",
-  "habr\xEDan",
-  "hab\xEDa",
-  "hab\xEDas",
-  "hab\xEDamos",
-  "hab\xEDais",
-  "hab\xEDan",
-  "hube",
-  "hubiste",
-  "hubo",
-  "hubimos",
-  "hubisteis",
-  "hubieron",
-  "hubiera",
-  "hubieras",
-  "hubi\xE9ramos",
-  "hubierais",
-  "hubieran",
-  "hubiese",
-  "hubieses",
-  "hubi\xE9semos",
-  "hubieseis",
-  "hubiesen",
-  "habiendo",
-  "habido",
-  "habida",
-  "habidos",
-  "habidas",
-  "soy",
-  "eres",
-  "es",
-  "somos",
-  "sois",
-  "son",
-  "sea",
-  "seas",
-  "seamos",
-  "se\xE1is",
-  "sean",
-  "ser\xE9",
-  "ser\xE1s",
-  "ser\xE1",
-  "seremos",
-  "ser\xE9is",
-  "ser\xE1n",
-  "ser\xEDa",
-  "ser\xEDas",
-  "ser\xEDamos",
-  "ser\xEDais",
-  "ser\xEDan",
-  "era",
-  "eras",
-  "\xE9ramos",
-  "erais",
-  "eran",
-  "fui",
-  "fuiste",
-  "fue",
-  "fuimos",
-  "fuisteis",
-  "fueron",
-  "fuera",
-  "fueras",
-  "fu\xE9ramos",
-  "fuerais",
-  "fueran",
-  "fuese",
-  "fueses",
-  "fu\xE9semos",
-  "fueseis",
-  "fuesen",
-  "siendo",
-  "sido",
-  "tengo",
-  "tienes",
-  "tiene",
-  "tenemos",
-  "ten\xE9is",
-  "tienen",
-  "tenga",
-  "tengas",
-  "tengamos",
-  "teng\xE1is",
-  "tengan",
-  "tendr\xE9",
-  "tendr\xE1s",
-  "tendr\xE1",
-  "tendremos",
-  "tendr\xE9is",
-  "tendr\xE1n",
-  "tendr\xEDa",
-  "tendr\xEDas",
-  "tendr\xEDamos",
-  "tendr\xEDais",
-  "tendr\xEDan",
-  "ten\xEDa",
-  "ten\xEDas",
-  "ten\xEDamos",
-  "ten\xEDais",
-  "ten\xEDan",
-  "tuve",
-  "tuviste",
-  "tuvo",
-  "tuvimos",
-  "tuvisteis",
-  "tuvieron",
-  "tuviera",
-  "tuvieras",
-  "tuvi\xE9ramos",
-  "tuvierais",
-  "tuvieran",
-  "tuviese",
-  "tuvieses",
-  "tuvi\xE9semos",
-  "tuvieseis",
-  "tuviesen",
-  "teniendo",
-  "tenido",
-  "tenida",
-  "tenidos",
-  "tenidas",
-  "tened"
-];
-
-// ../../node_modules/.pnpm/@orama+orama@1.0.0-beta.16/node_modules/@orama/orama/dist/components/tokenizer/stop-words/pt.js
-var pt = [
-  "de",
-  "a",
-  "o",
-  "que",
-  "e",
-  "do",
-  "da",
-  "em",
-  "um",
-  "para",
-  "com",
-  "n\xE3o",
-  "uma",
-  "os",
-  "no",
-  "se",
-  "na",
-  "por",
-  "mais",
-  "as",
-  "dos",
-  "como",
-  "mas",
-  "ao",
-  "ele",
-  "das",
-  "\xE0",
-  "seu",
-  "sua",
-  "ou",
-  "quando",
-  "muito",
-  "nos",
-  "j\xE1",
-  "eu",
-  "tamb\xE9m",
-  "s\xF3",
-  "pelo",
-  "pela",
-  "at\xE9",
-  "isso",
-  "ela",
-  "entre",
-  "depois",
-  "sem",
-  "mesmo",
-  "aos",
-  "seus",
-  "quem",
-  "nas",
-  "me",
-  "esse",
-  "eles",
-  "voc\xEA",
-  "essa",
-  "num",
-  "nem",
-  "suas",
-  "meu",
-  "\xE0s",
-  "minha",
-  "numa",
-  "pelos",
-  "elas",
-  "qual",
-  "n\xF3s",
-  "lhe",
-  "deles",
-  "essas",
-  "esses",
-  "pelas",
-  "este",
-  "dele",
-  "tu",
-  "te",
-  "voc\xEAs",
-  "vos",
-  "lhes",
-  "meus",
-  "minhas",
-  "teu",
-  "tua",
-  "teus",
-  "tuas",
-  "nosso",
-  "nossa",
-  "nossos",
-  "nossas",
-  "dela",
-  "delas",
-  "esta",
-  "estes",
-  "estas",
-  "aquele",
-  "aquela",
-  "aqueles",
-  "aquelas",
-  "isto",
-  "aquilo",
-  "estou",
-  "est\xE1",
-  "estamos",
-  "est\xE3o",
-  "estive",
-  "esteve",
-  "estivemos",
-  "estiveram",
-  "estava",
-  "est\xE1vamos",
-  "estavam",
-  "estivera",
-  "estiv\xE9ramos",
-  "esteja",
-  "estejamos",
-  "estejam",
-  "estivesse",
-  "estiv\xE9ssemos",
-  "estivessem",
-  "estiver",
-  "estivermos",
-  "estiverem",
-  "hei",
-  "h\xE1",
-  "havemos",
-  "h\xE3o",
-  "houve",
-  "houvemos",
-  "houveram",
-  "houvera",
-  "houv\xE9ramos",
-  "haja",
-  "hajamos",
-  "hajam",
-  "houvesse",
-  "houv\xE9ssemos",
-  "houvessem",
-  "houver",
-  "houvermos",
-  "houverem",
-  "houverei",
-  "houver\xE1",
-  "houveremos",
-  "houver\xE3o",
-  "houveria",
-  "houver\xEDamos",
-  "houveriam",
-  "sou",
-  "somos",
-  "s\xE3o",
-  "era",
-  "\xE9ramos",
-  "eram",
-  "fui",
-  "foi",
-  "fomos",
-  "foram",
-  "fora",
-  "f\xF4ramos",
-  "seja",
-  "sejamos",
-  "sejam",
-  "fosse",
-  "f\xF4ssemos",
-  "fossem",
-  "for",
-  "formos",
-  "forem",
-  "serei",
-  "ser\xE1",
-  "seremos",
-  "ser\xE3o",
-  "seria",
-  "ser\xEDamos",
-  "seriam",
-  "tenho",
-  "tem",
-  "temos",
-  "t\xE9m",
-  "tinha",
-  "t\xEDnhamos",
-  "tinham",
-  "tive",
-  "teve",
-  "tivemos",
-  "tiveram",
-  "tivera",
-  "tiv\xE9ramos",
-  "tenha",
-  "tenhamos",
-  "tenham",
-  "tivesse",
-  "tiv\xE9ssemos",
-  "tivessem",
-  "tiver",
-  "tivermos",
-  "tiverem",
-  "terei",
-  "ter\xE1",
-  "teremos",
-  "ter\xE3o",
-  "teria",
-  "ter\xEDamos",
-  "teriam"
-];
-
-// ../../node_modules/.pnpm/@orama+orama@1.0.0-beta.16/node_modules/@orama/orama/dist/components/tokenizer/stop-words/nl.js
-var nl = [
-  "de",
-  "en",
-  "van",
-  "ik",
-  "te",
-  "dat",
-  "die",
-  "in",
-  "een",
-  "hij",
-  "het",
-  "niet",
-  "zijn",
-  "is",
-  "was",
-  "op",
-  "aan",
-  "met",
-  "als",
-  "voor",
-  "had",
-  "er",
-  "maar",
-  "om",
-  "hem",
-  "dan",
-  "zou",
-  "of",
-  "wat",
-  "mijn",
-  "men",
-  "dit",
-  "zo",
-  "door",
-  "over",
-  "ze",
-  "zich",
-  "bij",
-  "ook",
-  "tot",
-  "je",
-  "mij",
-  "uit",
-  "der",
-  "daar",
-  "haar",
-  "naar",
-  "heb",
-  "hoe",
-  "heeft",
-  "hebben",
-  "deze",
-  "u",
-  "want",
-  "nog",
-  "zal",
-  "me",
-  "zij",
-  "nu",
-  "ge",
-  "geen",
-  "omdat",
-  "iets",
-  "worden",
-  "toch",
-  "al",
-  "waren",
-  "veel",
-  "meer",
-  "doen",
-  "toen",
-  "moet",
-  "ben",
-  "zonder",
-  "kan",
-  "hun",
-  "dus",
-  "alles",
-  "onder",
-  "ja",
-  "eens",
-  "hier",
-  "wie",
-  "werd",
-  "altijd",
-  "doch",
-  "wordt",
-  "wezen",
-  "kunnen",
-  "ons",
-  "zelf",
-  "tegen",
-  "na",
-  "reeds",
-  "wil",
-  "kon",
-  "niets",
-  "uw",
-  "iemand",
-  "geweest",
-  "andere"
-];
-
-// ../../node_modules/.pnpm/@orama+orama@1.0.0-beta.16/node_modules/@orama/orama/dist/components/tokenizer/stop-words/se.js
-var se = [
-  "och",
-  "det",
-  "att",
-  "i",
-  "en",
-  "jag",
-  "hon",
-  "som",
-  "han",
-  "p\xE5",
-  "den",
-  "med",
-  "var",
-  "sig",
-  "f\xF6r",
-  "s\xE5",
-  "till",
-  "\xE4r",
-  "men",
-  "ett",
-  "om",
-  "hade",
-  "de",
-  "av",
-  "icke",
-  "mig",
-  "du",
-  "henne",
-  "d\xE5",
-  "sin",
-  "nu",
-  "har",
-  "inte",
-  "hans",
-  "honom",
-  "skulle",
-  "hennes",
-  "d\xE4r",
-  "min",
-  "man",
-  "ej",
-  "vid",
-  "kunde",
-  "n\xE5got",
-  "fr\xE5n",
-  "ut",
-  "n\xE4r",
-  "efter",
-  "upp",
-  "vi",
-  "dem",
-  "vara",
-  "vad",
-  "\xF6ver",
-  "\xE4n",
-  "dig",
-  "kan",
-  "sina",
-  "h\xE4r",
-  "ha",
-  "mot",
-  "alla",
-  "under",
-  "n\xE5gon",
-  "eller",
-  "allt",
-  "mycket",
-  "sedan",
-  "ju",
-  "denna",
-  "sj\xE4lv",
-  "detta",
-  "\xE5t",
-  "utan",
-  "varit",
-  "hur",
-  "ingen",
-  "mitt",
-  "ni",
-  "bli",
-  "blev",
-  "oss",
-  "din",
-  "dessa",
-  "n\xE5gra",
-  "deras",
-  "blir",
-  "mina",
-  "samma",
-  "vilken",
-  "er",
-  "s\xE5dan",
-  "v\xE5r",
-  "blivit",
-  "dess",
-  "inom",
-  "mellan",
-  "s\xE5dant",
-  "varf\xF6r",
-  "varje",
-  "vilka",
-  "ditt",
-  "vem",
-  "vilket",
-  "sitta",
-  "s\xE5dana",
-  "vart",
-  "dina",
-  "vars",
-  "v\xE5rt",
-  "v\xE5ra",
-  "ert",
-  "era",
-  "vilkas"
-];
-
-// ../../node_modules/.pnpm/@orama+orama@1.0.0-beta.16/node_modules/@orama/orama/dist/components/tokenizer/stop-words/ru.js
-var ru = [
-  "\u0438",
-  "\u0432",
-  "\u0432\u043E",
-  "\u043D\u0435",
-  "\u0447\u0442\u043E",
-  "\u043E\u043D",
-  "\u043D\u0430",
-  "\u044F",
-  "\u0441",
-  "\u0441\u043E",
-  "\u043A\u0430\u043A",
-  "\u0430",
-  "\u0442\u043E",
-  "\u0432\u0441\u0435",
-  "\u043E\u043D\u0430",
-  "\u0442\u0430\u043A",
-  "\u0435\u0433\u043E",
-  "\u043D\u043E",
-  "\u0434\u0430",
-  "\u0442\u044B",
-  "\u043A",
-  "\u0443",
-  "\u0436\u0435",
-  "\u0432\u044B",
-  "\u0437\u0430",
-  "\u0431\u044B",
-  "\u043F\u043E",
-  "\u0442\u043E\u043B\u044C\u043A\u043E",
-  "\u0435\u0435",
-  "\u043C\u043D\u0435",
-  "\u0431\u044B\u043B\u043E",
-  "\u0432\u043E\u0442",
-  "\u043E\u0442",
-  "\u043C\u0435\u043D\u044F",
-  "\u0435\u0449\u0435",
-  "\u043D\u0435\u0442",
-  "\u043E",
-  "\u0438\u0437",
-  "\u0435\u043C\u0443",
-  "\u0442\u0435\u043F\u0435\u0440\u044C",
-  "\u043A\u043E\u0433\u0434\u0430",
-  "\u0434\u0430\u0436\u0435",
-  "\u043D\u0443",
-  "\u0432\u0434\u0440\u0443\u0433",
-  "\u043B\u0438",
-  "\u0435\u0441\u043B\u0438",
-  "\u0443\u0436\u0435",
-  "\u0438\u043B\u0438",
-  "\u043D\u0438",
-  "\u0431\u044B\u0442\u044C",
-  "\u0431\u044B\u043B",
-  "\u043D\u0435\u0433\u043E",
-  "\u0434\u043E",
-  "\u0432\u0430\u0441",
-  "\u043D\u0438\u0431\u0443\u0434\u044C",
-  "\u043E\u043F\u044F\u0442\u044C",
-  "\u0443\u0436",
-  "\u0432\u0430\u043C",
-  "\u0441\u043A\u0430\u0437\u0430\u043B",
-  "\u0432\u0435\u0434\u044C",
-  "\u0442\u0430\u043C",
-  "\u043F\u043E\u0442\u043E\u043C",
-  "\u0441\u0435\u0431\u044F",
-  "\u043D\u0438\u0447\u0435\u0433\u043E",
-  "\u0435\u0439",
-  "\u043C\u043E\u0436\u0435\u0442",
-  "\u043E\u043D\u0438",
-  "\u0442\u0443\u0442",
-  "\u0433\u0434\u0435",
-  "\u0435\u0441\u0442\u044C",
-  "\u043D\u0430\u0434\u043E",
-  "\u043D\u0435\u0439",
-  "\u0434\u043B\u044F",
-  "\u043C\u044B",
-  "\u0442\u0435\u0431\u044F",
-  "\u0438\u0445",
-  "\u0447\u0435\u043C",
-  "\u0431\u044B\u043B\u0430",
-  "\u0441\u0430\u043C",
-  "\u0447\u0442\u043E\u0431",
-  "\u0431\u0435\u0437",
-  "\u0431\u0443\u0434\u0442\u043E",
-  "\u0447\u0435\u043B\u043E\u0432\u0435\u043A",
-  "\u0447\u0435\u0433\u043E",
-  "\u0440\u0430\u0437",
-  "\u0442\u043E\u0436\u0435",
-  "\u0441\u0435\u0431\u0435",
-  "\u043F\u043E\u0434",
-  "\u0436\u0438\u0437\u043D\u044C",
-  "\u0431\u0443\u0434\u0435\u0442",
-  "\u0436",
-  "\u0442\u043E\u0433\u0434\u0430",
-  "\u043A\u0442\u043E",
-  "\u044D\u0442\u043E\u0442",
-  "\u0433\u043E\u0432\u043E\u0440\u0438\u043B",
-  "\u0442\u043E\u0433\u043E",
-  "\u043F\u043E\u0442\u043E\u043C\u0443",
-  "\u044D\u0442\u043E\u0433\u043E",
-  "\u043A\u0430\u043A\u043E\u0439",
-  "\u0441\u043E\u0432\u0441\u0435\u043C",
-  "\u043D\u0438\u043C",
-  "\u0437\u0434\u0435\u0441\u044C",
-  "\u044D\u0442\u043E\u043C",
-  "\u043E\u0434\u0438\u043D",
-  "\u043F\u043E\u0447\u0442\u0438",
-  "\u043C\u043E\u0439",
-  "\u0442\u0435\u043C",
-  "\u0447\u0442\u043E\u0431\u044B",
-  "\u043D\u0435\u0435",
-  "\u043A\u0430\u0436\u0435\u0442\u0441\u044F",
-  "\u0441\u0435\u0439\u0447\u0430\u0441",
-  "\u0431\u044B\u043B\u0438",
-  "\u043A\u0443\u0434\u0430",
-  "\u0437\u0430\u0447\u0435\u043C",
-  "\u0441\u043A\u0430\u0437\u0430\u0442\u044C",
-  "\u0432\u0441\u0435\u0445",
-  "\u043D\u0438\u043A\u043E\u0433\u0434\u0430",
-  "\u0441\u0435\u0433\u043E\u0434\u043D\u044F",
-  "\u043C\u043E\u0436\u043D\u043E",
-  "\u043F\u0440\u0438",
-  "\u043D\u0430\u043A\u043E\u043D\u0435\u0446",
-  "\u0434\u0432\u0430",
-  "\u043E\u0431",
-  "\u0434\u0440\u0443\u0433\u043E\u0439",
-  "\u0445\u043E\u0442\u044C",
-  "\u043F\u043E\u0441\u043B\u0435",
-  "\u043D\u0430\u0434",
-  "\u0431\u043E\u043B\u044C\u0448\u0435",
-  "\u0442\u043E\u0442",
-  "\u0447\u0435\u0440\u0435\u0437",
-  "\u044D\u0442\u0438",
-  "\u043D\u0430\u0441",
-  "\u043F\u0440\u043E",
-  "\u0432\u0441\u0435\u0433\u043E",
-  "\u043D\u0438\u0445",
-  "\u043A\u0430\u043A\u0430\u044F",
-  "\u043C\u043D\u043E\u0433\u043E",
-  "\u0440\u0430\u0437\u0432\u0435",
-  "\u0441\u043A\u0430\u0437\u0430\u043B\u0430",
-  "\u0442\u0440\u0438",
-  "\u044D\u0442\u0443",
-  "\u043C\u043E\u044F",
-  "\u0432\u043F\u0440\u043E\u0447\u0435\u043C",
-  "\u0445\u043E\u0440\u043E\u0448\u043E",
-  "\u0441\u0432\u043E\u044E",
-  "\u044D\u0442\u043E\u0439",
-  "\u043F\u0435\u0440\u0435\u0434",
-  "\u0438\u043D\u043E\u0433\u0434\u0430",
-  "\u043B\u0443\u0447\u0448\u0435",
-  "\u0447\u0443\u0442\u044C",
-  "\u0442\u043E\u043C",
-  "\u043D\u0435\u043B\u044C\u0437\u044F",
-  "\u0442\u0430\u043A\u043E\u0439",
-  "\u0438\u043C",
-  "\u0431\u043E\u043B\u0435\u0435",
-  "\u0432\u0441\u0435\u0433\u0434\u0430",
-  "\u043A\u043E\u043D\u0435\u0447\u043D\u043E",
-  "\u0432\u0441\u044E",
-  "\u043C\u0435\u0436\u0434\u0443"
-];
-
-// ../../node_modules/.pnpm/@orama+orama@1.0.0-beta.16/node_modules/@orama/orama/dist/components/tokenizer/stop-words/no.js
-var no = [
-  "og",
-  "i",
-  "jeg",
-  "det",
-  "at",
-  "en",
-  "et",
-  "den",
-  "til",
-  "er",
-  "som",
-  "p\xE5",
-  "de",
-  "med",
-  "han",
-  "av",
-  "ikke",
-  "ikkje",
-  "der",
-  "s\xE5",
-  "var",
-  "meg",
-  "seg",
-  "men",
-  "ett",
-  "har",
-  "om",
-  "vi",
-  "min",
-  "mitt",
-  "ha",
-  "hadde",
-  "hun",
-  "n\xE5",
-  "over",
-  "da",
-  "ved",
-  "fra",
-  "du",
-  "ut",
-  "sin",
-  "dem",
-  "oss",
-  "opp",
-  "man",
-  "kan",
-  "hans",
-  "hvor",
-  "eller",
-  "hva",
-  "skal",
-  "selv",
-  "sj\xF8l",
-  "her",
-  "alle",
-  "vil",
-  "bli",
-  "ble",
-  "blei",
-  "blitt",
-  "kunne",
-  "inn",
-  "n\xE5r",
-  "v\xE6re",
-  "kom",
-  "noen",
-  "noe",
-  "ville",
-  "dere",
-  "som",
-  "deres",
-  "kun",
-  "ja",
-  "etter",
-  "ned",
-  "skulle",
-  "denne",
-  "for",
-  "deg",
-  "si",
-  "sine",
-  "sitt",
-  "mot",
-  "\xE5",
-  "meget",
-  "hvorfor",
-  "dette",
-  "disse",
-  "uten",
-  "hvordan",
-  "ingen",
-  "din",
-  "ditt",
-  "blir",
-  "samme",
-  "hvilken",
-  "hvilke",
-  "s\xE5nn",
-  "inni",
-  "mellom",
-  "v\xE5r",
-  "hver",
-  "hvem",
-  "vors",
-  "hvis",
-  "b\xE5de",
-  "bare",
-  "enn",
-  "fordi",
-  "f\xF8r",
-  "mange",
-  "ogs\xE5",
-  "slik",
-  "v\xE6rt",
-  "v\xE6re",
-  "b\xE5e",
-  "begge",
-  "siden",
-  "dykk",
-  "dykkar",
-  "dei",
-  "deira",
-  "deires",
-  "deim",
-  "di",
-  "d\xE5",
-  "eg",
-  "ein",
-  "eit",
-  "eitt",
-  "elles",
-  "honom",
-  "hj\xE5",
-  "ho",
-  "hoe",
-  "henne",
-  "hennar",
-  "hennes",
-  "hoss",
-  "hossen",
-  "ikkje",
-  "ingi",
-  "inkje",
-  "korleis",
-  "korso",
-  "kva",
-  "kvar",
-  "kvarhelst",
-  "kven",
-  "kvi",
-  "kvifor",
-  "me",
-  "medan",
-  "mi",
-  "mine",
-  "mykje",
-  "no",
-  "nokon",
-  "noka",
-  "nokor",
-  "noko",
-  "nokre",
-  "si",
-  "sia",
-  "sidan",
-  "so",
-  "somt",
-  "somme",
-  "um",
-  "upp",
-  "vere",
-  "vore",
-  "verte",
-  "vort",
-  "varte",
-  "vart"
-];
-
-// ../../node_modules/.pnpm/@orama+orama@1.0.0-beta.16/node_modules/@orama/orama/dist/components/tokenizer/stop-words/de.js
-var de = [
-  "aber",
-  "alle",
-  "allem",
-  "allen",
-  "aller",
-  "alles",
-  "als",
-  "also",
-  "am",
-  "an",
-  "ander",
-  "andere",
-  "anderem",
-  "anderen",
-  "anderer",
-  "anderes",
-  "anderm",
-  "andern",
-  "anderr",
-  "anders",
-  "auch",
-  "auf",
-  "aus",
-  "bei",
-  "bin",
-  "bis",
-  "bist",
-  "da",
-  "damit",
-  "dann",
-  "der",
-  "den",
-  "des",
-  "dem",
-  "die",
-  "das",
-  "da\xDF",
-  "derselbe",
-  "derselben",
-  "denselben",
-  "desselben",
-  "demselben",
-  "dieselbe",
-  "dieselben",
-  "dasselbe",
-  "dazu",
-  "dein",
-  "deine",
-  "deinem",
-  "deinen",
-  "deiner",
-  "deines",
-  "denn",
-  "derer",
-  "dessen",
-  "dich",
-  "dir",
-  "du",
-  "dies",
-  "diese",
-  "diesem",
-  "diesen",
-  "dieser",
-  "dieses",
-  "doch",
-  "dort",
-  "durch",
-  "ein",
-  "eine",
-  "einem",
-  "einen",
-  "einer",
-  "eines",
-  "einig",
-  "einige",
-  "einigem",
-  "einigen",
-  "einiger",
-  "einiges",
-  "einmal",
-  "er",
-  "ihn",
-  "ihm",
-  "es",
-  "etwas",
-  "euer",
-  "eure",
-  "eurem",
-  "euren",
-  "eurer",
-  "eures",
-  "f\xFCr",
-  "gegen",
-  "gewesen",
-  "hab",
-  "habe",
-  "haben",
-  "hat",
-  "hatte",
-  "hatten",
-  "hier",
-  "hin",
-  "hinter",
-  "ich",
-  "mich",
-  "mir",
-  "ihr",
-  "ihre",
-  "ihrem",
-  "ihren",
-  "ihrer",
-  "ihres",
-  "euch",
-  "im",
-  "in",
-  "indem",
-  "ins",
-  "ist",
-  "jede",
-  "jedem",
-  "jeden",
-  "jeder",
-  "jedes",
-  "jene",
-  "jenem",
-  "jenen",
-  "jener",
-  "jenes",
-  "jetzt",
-  "kann",
-  "kein",
-  "keine",
-  "keinem",
-  "keinen",
-  "keiner",
-  "keines",
-  "k\xF6nnen",
-  "k\xF6nnte",
-  "machen",
-  "man",
-  "manche",
-  "manchem",
-  "manchen",
-  "mancher",
-  "manches",
-  "mein",
-  "meine",
-  "meinem",
-  "meinen",
-  "meiner",
-  "meines",
-  "mit",
-  "muss",
-  "musste",
-  "nach",
-  "nicht",
-  "nichts",
-  "noch",
-  "nun",
-  "nur",
-  "ob",
-  "oder",
-  "ohne",
-  "sehr",
-  "sein",
-  "seine",
-  "seinem",
-  "seinen",
-  "seiner",
-  "seines",
-  "selbst",
-  "sich",
-  "sie",
-  "ihnen",
-  "sind",
-  "so",
-  "solche",
-  "solchem",
-  "solchen",
-  "solcher",
-  "solches",
-  "soll",
-  "sollte",
-  "sondern",
-  "sonst",
-  "\xFCber",
-  "um",
-  "und",
-  "uns",
-  "unse",
-  "unsem",
-  "unsen",
-  "unser",
-  "unses",
-  "unter",
-  "viel",
-  "vom",
-  "von",
-  "vor",
-  "w\xE4hrend",
-  "war",
-  "waren",
-  "warst",
-  "was",
-  "weg",
-  "weil",
-  "weiter",
-  "welche",
-  "welchem",
-  "welchen",
-  "welcher",
-  "welches",
-  "wenn",
-  "werde",
-  "werden",
-  "wie",
-  "wieder",
-  "will",
-  "wir",
-  "wird",
-  "wirst",
-  "wo",
-  "wollen",
-  "wollte",
-  "w\xFCrde",
-  "w\xFCrden",
-  "zu",
-  "zum",
-  "zur",
-  "zwar",
-  "zwischen"
-];
-
-// ../../node_modules/.pnpm/@orama+orama@1.0.0-beta.16/node_modules/@orama/orama/dist/components/tokenizer/stop-words/dk.js
-var dk = [
-  "og",
-  "i",
-  "jeg",
-  "det",
-  "at",
-  "en",
-  "den",
-  "til",
-  "er",
-  "som",
-  "p\xE5",
-  "de",
-  "med",
-  "han",
-  "af",
-  "for",
-  "ikke",
-  "der",
-  "var",
-  "mig",
-  "sig",
-  "men",
-  "et",
-  "har",
-  "om",
-  "vi",
-  "min",
-  "havde",
-  "ham",
-  "hun",
-  "nu",
-  "over",
-  "da",
-  "fra",
-  "du",
-  "ud",
-  "sin",
-  "dem",
-  "os",
-  "op",
-  "man",
-  "hans",
-  "hvor",
-  "eller",
-  "hvad",
-  "skal",
-  "selv",
-  "her",
-  "alle",
-  "vil",
-  "blev",
-  "kunne",
-  "ind",
-  "n\xE5r",
-  "v\xE6re",
-  "dog",
-  "noget",
-  "ville",
-  "jo",
-  "deres",
-  "efter",
-  "ned",
-  "skulle",
-  "denne",
-  "end",
-  "dette",
-  "mit",
-  "ogs\xE5",
-  "under",
-  "have",
-  "dig",
-  "anden",
-  "hende",
-  "mine",
-  "alt",
-  "meget",
-  "sit",
-  "sine",
-  "vor",
-  "mod",
-  "disse",
-  "hvis",
-  "din",
-  "nogle",
-  "hos",
-  "blive",
-  "mange",
-  "ad",
-  "bliver",
-  "hendes",
-  "v\xE6ret",
-  "thi",
-  "jer",
-  "s\xE5dan"
-];
-
-// ../../node_modules/.pnpm/@orama+orama@1.0.0-beta.16/node_modules/@orama/orama/dist/components/tokenizer/stop-words/fi.js
-var fi = [
-  "olla",
-  "olen",
-  "olet",
-  "on",
-  "olemme",
-  "olette",
-  "ovat",
-  "ole",
-  "oli",
-  "olisi",
-  "olisit",
-  "olisin",
-  "olisimme",
-  "olisitte",
-  "olisivat",
-  "olit",
-  "olin",
-  "olimme",
-  "olitte",
-  "olivat",
-  "ollut",
-  "olleet",
-  "en",
-  "et",
-  "ei",
-  "emme",
-  "ette",
-  "eiv\xE4t",
-  "min\xE4",
-  "minun",
-  "minut",
-  "minua",
-  "minussa",
-  "minusta",
-  "minuun",
-  "minulla",
-  "minulta",
-  "minulle",
-  "sin\xE4",
-  "sinun",
-  "sinut",
-  "sinua",
-  "sinussa",
-  "sinusta",
-  "sinuun",
-  "sinulla",
-  "sinulta",
-  "sinulle",
-  "h\xE4n",
-  "h\xE4nen",
-  "h\xE4net",
-  "h\xE4nt\xE4",
-  "h\xE4ness\xE4",
-  "h\xE4nest\xE4",
-  "h\xE4neen",
-  "h\xE4nell\xE4",
-  "h\xE4nelt\xE4",
-  "h\xE4nelle",
-  "me",
-  "meid\xE4n",
-  "meid\xE4t",
-  "meit\xE4",
-  "meiss\xE4",
-  "meist\xE4",
-  "meihin",
-  "meill\xE4",
-  "meilt\xE4",
-  "meille",
-  "te",
-  "teid\xE4n",
-  "teid\xE4t",
-  "teit\xE4",
-  "teiss\xE4",
-  "teist\xE4",
-  "teihin",
-  "teill\xE4",
-  "teilt\xE4",
-  "teille",
-  "he",
-  "heid\xE4n",
-  "heid\xE4t",
-  "heit\xE4",
-  "heiss\xE4",
-  "heist\xE4",
-  "heihin",
-  "heill\xE4",
-  "heilt\xE4",
-  "heille",
-  "t\xE4m\xE4",
-  "t\xE4m\xE4n",
-  "t\xE4t\xE4",
-  "t\xE4ss\xE4",
-  "t\xE4st\xE4",
-  "t\xE4h\xE4n",
-  "t\xE4ll\xE4",
-  "t\xE4lt\xE4",
-  "t\xE4lle",
-  "t\xE4n\xE4",
-  "t\xE4ksi",
-  "tuo",
-  "tuon",
-  "tuota",
-  "tuossa",
-  "tuosta",
-  "tuohon",
-  "tuolla",
-  "tuolta",
-  "tuolle",
-  "tuona",
-  "tuoksi",
-  "se",
-  "sen",
-  "sit\xE4",
-  "siin\xE4",
-  "siit\xE4",
-  "siihen",
-  "sill\xE4",
-  "silt\xE4",
-  "sille",
-  "sin\xE4",
-  "siksi",
-  "n\xE4m\xE4",
-  "n\xE4iden",
-  "n\xE4it\xE4",
-  "n\xE4iss\xE4",
-  "n\xE4ist\xE4",
-  "n\xE4ihin",
-  "n\xE4ill\xE4",
-  "n\xE4ilt\xE4",
-  "n\xE4ille",
-  "n\xE4in\xE4",
-  "n\xE4iksi",
-  "nuo",
-  "noiden",
-  "noita",
-  "noissa",
-  "noista",
-  "noihin",
-  "noilla",
-  "noilta",
-  "noille",
-  "noina",
-  "noiksi",
-  "ne",
-  "niiden",
-  "niit\xE4",
-  "niiss\xE4",
-  "niist\xE4",
-  "niihin",
-  "niill\xE4",
-  "niilt\xE4",
-  "niille",
-  "niin\xE4",
-  "niiksi",
-  "kuka",
-  "kenen",
-  "kenet",
-  "ket\xE4",
-  "keness\xE4",
-  "kenest\xE4",
-  "keneen",
-  "kenell\xE4",
-  "kenelt\xE4",
-  "kenelle",
-  "kenen\xE4",
-  "keneksi",
-  "ketk\xE4",
-  "keiden",
-  "ketk\xE4",
-  "keit\xE4",
-  "keiss\xE4",
-  "keist\xE4",
-  "keihin",
-  "keill\xE4",
-  "keilt\xE4",
-  "keille",
-  "kein\xE4",
-  "keiksi",
-  "mik\xE4",
-  "mink\xE4",
-  "mink\xE4",
-  "mit\xE4",
-  "miss\xE4",
-  "mist\xE4",
-  "mihin",
-  "mill\xE4",
-  "milt\xE4",
-  "mille",
-  "min\xE4",
-  "miksi",
-  "mitk\xE4",
-  "joka",
-  "jonka",
-  "jota",
-  "jossa",
-  "josta",
-  "johon",
-  "jolla",
-  "jolta",
-  "jolle",
-  "jona",
-  "joksi",
-  "jotka",
-  "joiden",
-  "joita",
-  "joissa",
-  "joista",
-  "joihin",
-  "joilla",
-  "joilta",
-  "joille",
-  "joina",
-  "joiksi",
-  "ett\xE4",
-  "ja",
-  "jos",
-  "koska",
-  "kuin",
-  "mutta",
-  "niin",
-  "sek\xE4",
-  "sill\xE4",
-  "tai",
-  "vaan",
-  "vai",
-  "vaikka",
-  "kanssa",
-  "mukaan",
-  "noin",
-  "poikki",
-  "yli",
-  "kun",
-  "niin",
-  "nyt",
-  "itse"
-];
-
-// ../../node_modules/.pnpm/@orama+orama@1.0.0-beta.16/node_modules/@orama/orama/dist/components/tokenizer/stop-words/index.js
-var stopWords = {
-  english: en,
-  italian: it,
-  french: fr,
-  spanish: es,
-  portuguese: pt,
-  dutch: nl,
-  swedish: se,
-  russian: ru,
-  norwegian: no,
-  german: de,
-  danish: dk,
-  finnish: fi
-};
-var availableStopWords = Object.keys(stopWords);
-
-// ../../node_modules/.pnpm/@orama+orama@1.0.0-beta.16/node_modules/@orama/orama/dist/components/tokenizer/english-stemmer.js
+// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/components/tokenizer/english-stemmer.js
 var step2List = {
   ational: "ate",
   tional: "tion",
@@ -4636,7 +2540,7 @@ function stemmer(w) {
   return w;
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.0.0-beta.16/node_modules/@orama/orama/dist/components/tokenizer/index.js
+// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/components/tokenizer/index.js
 function normalizeToken(prop, token) {
   var _this_stopWords;
   const key = `${this.language}:${prop}:${token}`;
@@ -4681,7 +2585,6 @@ function tokenize(input, language, prop) {
   return trimTokens;
 }
 async function createTokenizer(config = {}) {
-  var _a2;
   if (!config.language) {
     config.language = "english";
   } else if (!SUPPORTED_LANGUAGES.includes(config.language)) {
@@ -4702,20 +2605,20 @@ async function createTokenizer(config = {}) {
       }
     }
   }
-  let stopWords2;
+  let stopWords;
   if (config.stopWords !== false) {
-    stopWords2 = (_a2 = stopWords[config.language]) != null ? _a2 : [];
+    stopWords = [];
     if (Array.isArray(config.stopWords)) {
-      stopWords2 = config.stopWords;
+      stopWords = config.stopWords;
     } else if (typeof config.stopWords === "function") {
-      stopWords2 = await config.stopWords(stopWords2);
+      stopWords = await config.stopWords(stopWords);
     } else if (config.stopWords) {
       throw createError("CUSTOM_STOP_WORDS_MUST_BE_FUNCTION_OR_ARRAY");
     }
-    if (!Array.isArray(stopWords2)) {
+    if (!Array.isArray(stopWords)) {
       throw createError("CUSTOM_STOP_WORDS_MUST_BE_FUNCTION_OR_ARRAY");
     }
-    for (const s of stopWords2) {
+    for (const s of stopWords) {
       if (typeof s !== "string") {
         throw createError("CUSTOM_STOP_WORDS_MUST_BE_FUNCTION_OR_ARRAY");
       }
@@ -4728,7 +2631,7 @@ async function createTokenizer(config = {}) {
     stemmerSkipProperties: new Set(config.stemmerSkipProperties ? [
       config.stemmerSkipProperties
     ].flat() : []),
-    stopWords: stopWords2,
+    stopWords,
     allowDuplicates: Boolean(config.allowDuplicates),
     normalizeToken,
     normalizationCache: /* @__PURE__ */ new Map()
@@ -4738,7 +2641,255 @@ async function createTokenizer(config = {}) {
   return tokenizer;
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.0.0-beta.16/node_modules/@orama/orama/dist/methods/create.js
+// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/components/sorter.js
+function innerCreate(orama, sharedInternalDocumentStore, schema, sortableDeniedProperties, prefix) {
+  const sorter = {
+    language: orama.tokenizer.language,
+    sharedInternalDocumentStore,
+    enabled: true,
+    isSorted: true,
+    sortableProperties: [],
+    sortablePropertiesWithTypes: {},
+    sorts: {}
+  };
+  for (const [prop, type] of Object.entries(schema)) {
+    const typeActualType = typeof type;
+    const path = `${prefix}${prefix ? "." : ""}${prop}`;
+    if (sortableDeniedProperties.includes(path)) {
+      continue;
+    }
+    if (typeActualType === "object" && !Array.isArray(type)) {
+      const ret = innerCreate(orama, sharedInternalDocumentStore, type, sortableDeniedProperties, path);
+      sorter.sortableProperties.push(...ret.sortableProperties);
+      sorter.sorts = __spreadValues(__spreadValues({}, sorter.sorts), ret.sorts);
+      sorter.sortablePropertiesWithTypes = __spreadValues(__spreadValues({}, sorter.sortablePropertiesWithTypes), ret.sortablePropertiesWithTypes);
+      continue;
+    }
+    switch (type) {
+      case "boolean":
+      case "number":
+      case "string":
+        sorter.sortableProperties.push(path);
+        sorter.sortablePropertiesWithTypes[path] = type;
+        sorter.sorts[path] = {
+          docs: /* @__PURE__ */ new Map(),
+          orderedDocsToRemove: /* @__PURE__ */ new Map(),
+          orderedDocs: [],
+          type
+        };
+        break;
+      case "boolean[]":
+      case "number[]":
+      case "string[]":
+        continue;
+      default:
+        throw createError("INVALID_SORT_SCHEMA_TYPE", Array.isArray(type) ? "array" : type, path);
+    }
+  }
+  return sorter;
+}
+async function create5(orama, sharedInternalDocumentStore, schema, config) {
+  const isSortEnabled = (config === null || config === void 0 ? void 0 : config.enabled) !== false;
+  if (!isSortEnabled) {
+    return {
+      disabled: true
+    };
+  }
+  return innerCreate(orama, sharedInternalDocumentStore, schema, (config || {}).unsortableProperties || [], "");
+}
+async function insert4(sorter, prop, id, value) {
+  if (!sorter.enabled) {
+    return;
+  }
+  sorter.isSorted = false;
+  const internalId = getInternalDocumentId(sorter.sharedInternalDocumentStore, id);
+  const s = sorter.sorts[prop];
+  s.docs.set(internalId, s.orderedDocs.length);
+  s.orderedDocs.push([
+    internalId,
+    value
+  ]);
+}
+function ensureIsSorted(sorter) {
+  if (sorter.isSorted) {
+    return;
+  }
+  if (!sorter.enabled) {
+    return;
+  }
+  const properties = Object.keys(sorter.sorts);
+  for (const prop of properties) {
+    ensurePropertyIsSorted(sorter, prop);
+  }
+  sorter.isSorted = true;
+}
+function stringSort(language, value, d) {
+  return value[1].localeCompare(d[1], language);
+}
+function numberSort(value, d) {
+  return value[1] - d[1];
+}
+function booleanSort(value, d) {
+  return d[1] ? -1 : 1;
+}
+function ensurePropertyIsSorted(sorter, prop) {
+  const s = sorter.sorts[prop];
+  let predicate;
+  switch (s.type) {
+    case "string":
+      predicate = stringSort.bind(null, sorter.language);
+      break;
+    case "number":
+      predicate = numberSort.bind(null);
+      break;
+    case "boolean":
+      predicate = booleanSort.bind(null);
+      break;
+  }
+  s.orderedDocs.sort(predicate);
+  const orderedDocsLength = s.orderedDocs.length;
+  for (let i = 0; i < orderedDocsLength; i++) {
+    const docId = s.orderedDocs[i][0];
+    s.docs.set(docId, i);
+  }
+}
+function ensureOrderedDocsAreDeleted(sorter) {
+  const properties = Object.keys(sorter.sorts);
+  for (const prop of properties) {
+    ensureOrderedDocsAreDeletedByProperty(sorter, prop);
+  }
+}
+function ensureOrderedDocsAreDeletedByProperty(sorter, prop) {
+  const s = sorter.sorts[prop];
+  if (!s.orderedDocsToRemove.size)
+    return;
+  s.orderedDocs = s.orderedDocs.filter((doc) => !s.orderedDocsToRemove.has(doc[0]));
+  s.orderedDocsToRemove.clear();
+}
+async function remove4(sorter, prop, id) {
+  if (!sorter.enabled) {
+    return;
+  }
+  const s = sorter.sorts[prop];
+  const internalId = getInternalDocumentId(sorter.sharedInternalDocumentStore, id);
+  const index = s.docs.get(internalId);
+  if (!index)
+    return;
+  s.docs.delete(internalId);
+  s.orderedDocsToRemove.set(internalId, true);
+}
+async function sortBy(sorter, docIds, by) {
+  if (!sorter.enabled) {
+    throw createError("SORT_DISABLED");
+  }
+  const property = by.property;
+  const isDesc = by.order === "DESC";
+  const s = sorter.sorts[property];
+  if (!s) {
+    throw createError("UNABLE_TO_SORT_ON_UNKNOWN_FIELD", property, sorter.sortableProperties.join(", "));
+  }
+  ensureOrderedDocsAreDeletedByProperty(sorter, property);
+  ensureIsSorted(sorter);
+  docIds.sort((a, b) => {
+    const indexOfA = s.docs.get(getInternalDocumentId(sorter.sharedInternalDocumentStore, a[0]));
+    const indexOfB = s.docs.get(getInternalDocumentId(sorter.sharedInternalDocumentStore, b[0]));
+    const isAIndexed = typeof indexOfA !== "undefined";
+    const isBIndexed = typeof indexOfB !== "undefined";
+    if (!isAIndexed && !isBIndexed) {
+      return 0;
+    }
+    if (!isAIndexed) {
+      return 1;
+    }
+    if (!isBIndexed) {
+      return -1;
+    }
+    return isDesc ? indexOfB - indexOfA : indexOfA - indexOfB;
+  });
+  return docIds;
+}
+async function getSortableProperties(sorter) {
+  if (!sorter.enabled) {
+    return [];
+  }
+  return sorter.sortableProperties;
+}
+async function getSortablePropertiesWithTypes(sorter) {
+  if (!sorter.enabled) {
+    return {};
+  }
+  return sorter.sortablePropertiesWithTypes;
+}
+async function load4(sharedInternalDocumentStore, raw) {
+  const rawDocument = raw;
+  if (!rawDocument.enabled) {
+    return {
+      enabled: false
+    };
+  }
+  const sorts = Object.keys(rawDocument.sorts).reduce((acc, prop) => {
+    const { docs, orderedDocs, type } = rawDocument.sorts[prop];
+    acc[prop] = {
+      docs: new Map(Object.entries(docs).map(([k, v2]) => [
+        +k,
+        v2
+      ])),
+      orderedDocsToRemove: /* @__PURE__ */ new Map(),
+      orderedDocs,
+      type
+    };
+    return acc;
+  }, {});
+  return {
+    sharedInternalDocumentStore,
+    language: rawDocument.language,
+    sortableProperties: rawDocument.sortableProperties,
+    sortablePropertiesWithTypes: rawDocument.sortablePropertiesWithTypes,
+    sorts,
+    enabled: true,
+    isSorted: rawDocument.isSorted
+  };
+}
+async function save4(sorter) {
+  if (!sorter.enabled) {
+    return {
+      enabled: false
+    };
+  }
+  ensureOrderedDocsAreDeleted(sorter);
+  ensureIsSorted(sorter);
+  const sorts = Object.keys(sorter.sorts).reduce((acc, prop) => {
+    const { docs, orderedDocs, type } = sorter.sorts[prop];
+    acc[prop] = {
+      docs: Object.fromEntries(docs.entries()),
+      orderedDocs,
+      type
+    };
+    return acc;
+  }, {});
+  return {
+    language: sorter.language,
+    sortableProperties: sorter.sortableProperties,
+    sortablePropertiesWithTypes: sorter.sortablePropertiesWithTypes,
+    sorts,
+    enabled: sorter.enabled,
+    isSorted: sorter.isSorted
+  };
+}
+async function createSorter() {
+  return {
+    create: create5,
+    insert: insert4,
+    remove: remove4,
+    save: save4,
+    load: load4,
+    sortBy,
+    getSortableProperties,
+    getSortablePropertiesWithTypes
+  };
+}
+
+// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/methods/create.js
 function validateComponents(components) {
   const defaultComponents = {
     formatElapsedTime,
@@ -4758,7 +2909,8 @@ function validateComponents(components) {
   }
   for (const rawKey of SINGLE_OR_ARRAY_COMPONENTS) {
     const key = rawKey;
-    if (!components[key]) {
+    const component = components[key];
+    if (!component) {
       components[key] = [];
     } else if (!Array.isArray(components[key])) {
       components[key] = [
@@ -4777,7 +2929,7 @@ function validateComponents(components) {
     }
   }
 }
-async function create5({ schema, language, components, id }) {
+async function create6({ schema, sort, language, components, id }) {
   if (!components) {
     components = {};
   }
@@ -4787,6 +2939,7 @@ async function create5({ schema, language, components, id }) {
   let tokenizer = components.tokenizer;
   let index = components.index;
   let documentsStore = components.documentsStore;
+  let sorter = components.sorter;
   if (!tokenizer) {
     tokenizer = await createTokenizer({
       language: language != null ? language : "english"
@@ -4797,21 +2950,21 @@ async function create5({ schema, language, components, id }) {
   if (components.tokenizer && language) {
     throw createError("NO_LANGUAGE_WITH_CUSTOM_TOKENIZER");
   }
-  if (!index) {
-    index = await createIndex();
-  }
-  if (!documentsStore) {
-    documentsStore = await createDocumentsStore();
-  }
+  const internalDocumentStore = createInternalDocumentIDStore();
+  index || (index = await createIndex());
+  sorter || (sorter = await createSorter());
+  documentsStore || (documentsStore = await createDocumentsStore());
   validateComponents(components);
-  const { getDocumentProperties: getDocumentProperties2, getDocumentIndexId: getDocumentIndexId2, validateSchema: validateSchema2, beforeInsert, afterInsert, beforeRemove, afterRemove, beforeMultipleInsert, afterMultipleInsert, beforeMultipleRemove, afterMultipleRemove, formatElapsedTime: formatElapsedTime2 } = components;
+  const { getDocumentProperties: getDocumentProperties2, getDocumentIndexId: getDocumentIndexId2, validateSchema: validateSchema2, beforeInsert, afterInsert, beforeRemove, afterRemove, beforeUpdate, afterUpdate, afterSearch, beforeMultipleInsert, afterMultipleInsert, beforeMultipleRemove, afterMultipleRemove, beforeMultipleUpdate, afterMultipleUpdate, formatElapsedTime: formatElapsedTime2 } = components;
   const orama = {
     data: {},
     caches: {},
     schema,
     tokenizer,
     index,
+    sorter,
     documentsStore,
+    internalDocumentIDStore: internalDocumentStore,
     getDocumentProperties: getDocumentProperties2,
     getDocumentIndexId: getDocumentIndexId2,
     validateSchema: validateSchema2,
@@ -4819,25 +2972,31 @@ async function create5({ schema, language, components, id }) {
     afterInsert,
     beforeRemove,
     afterRemove,
+    beforeUpdate,
+    afterUpdate,
+    afterSearch,
     beforeMultipleInsert,
     afterMultipleInsert,
     beforeMultipleRemove,
     afterMultipleRemove,
+    beforeMultipleUpdate,
+    afterMultipleUpdate,
     formatElapsedTime: formatElapsedTime2,
     id
   };
   orama.data = {
-    index: await orama.index.create(orama, schema),
-    docs: await orama.documentsStore.create(orama)
+    index: await orama.index.create(orama, internalDocumentStore, schema),
+    docs: await orama.documentsStore.create(orama, internalDocumentStore),
+    sorting: await orama.sorter.create(orama, internalDocumentStore, schema, sort)
   };
   return orama;
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.0.0-beta.16/node_modules/@orama/orama/dist/types.js
+// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/types.js
 var kInsertions = Symbol("orama.insertions");
 var kRemovals = Symbol("orama.removals");
 
-// ../../node_modules/.pnpm/@orama+orama@1.0.0-beta.16/node_modules/@orama/orama/dist/components/sync-blocking-checker.js
+// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/components/sync-blocking-checker.js
 var _globalThis_process;
 var _a;
 var warn = (_a = (_globalThis_process = globalThis.process) === null || _globalThis_process === void 0 ? void 0 : _globalThis_process.emitWarning) != null ? _a : function emitWarning(message, options) {
@@ -4876,9 +3035,15 @@ function trackRemoval(orama) {
   }
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.0.0-beta.16/node_modules/@orama/orama/dist/methods/insert.js
-async function insert4(orama, doc, language, skipHooks) {
-  await orama.validateSchema(doc, orama.schema);
+// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/methods/insert.js
+async function insert5(orama, doc, language, skipHooks) {
+  const errorProperty = await orama.validateSchema(doc, orama.schema);
+  if (errorProperty) {
+    throw createError("SCHEMA_VALIDATION_FAILURE", errorProperty);
+  }
+  return innerInsert(orama, doc, language, skipHooks);
+}
+async function innerInsert(orama, doc, language, skipHooks) {
   const { index, docs } = orama.data;
   const id = await orama.getDocumentIndexId(doc);
   if (typeof id !== "string") {
@@ -4893,26 +3058,41 @@ async function insert4(orama, doc, language, skipHooks) {
   }
   const indexableProperties = await orama.index.getSearchableProperties(index);
   const indexablePropertiesWithTypes = await orama.index.getSearchablePropertiesWithTypes(index);
-  const values = await orama.getDocumentProperties(doc, indexableProperties);
-  for (const [key, value] of Object.entries(values)) {
+  const indexableValues = await orama.getDocumentProperties(doc, indexableProperties);
+  for (const [key, value] of Object.entries(indexableValues)) {
     if (typeof value === "undefined") {
       continue;
     }
     const actualType = typeof value;
     const expectedType = indexablePropertiesWithTypes[key];
+    if (isArrayType(expectedType) && Array.isArray(value)) {
+      continue;
+    }
     if (actualType !== expectedType) {
       throw createError("INVALID_DOCUMENT_PROPERTY", key, expectedType, actualType);
     }
   }
   for (const prop of indexableProperties) {
     var _orama_index, _orama_index_beforeInsert, _orama_index1, _orama_index_afterInsert;
-    const value = values[prop];
+    const value = indexableValues[prop];
+    if (typeof value === "undefined") {
+      continue;
+    }
+    const expectedType = indexablePropertiesWithTypes[prop];
+    await ((_orama_index_beforeInsert = (_orama_index = orama.index).beforeInsert) === null || _orama_index_beforeInsert === void 0 ? void 0 : _orama_index_beforeInsert.call(_orama_index, orama.data.index, prop, id, value, expectedType, language, orama.tokenizer, docsCount));
+    await orama.index.insert(orama.index, orama.data.index, prop, id, value, expectedType, language, orama.tokenizer, docsCount);
+    await ((_orama_index_afterInsert = (_orama_index1 = orama.index).afterInsert) === null || _orama_index_afterInsert === void 0 ? void 0 : _orama_index_afterInsert.call(_orama_index1, orama.data.index, prop, id, value, expectedType, language, orama.tokenizer, docsCount));
+  }
+  const sortableProperties = await orama.sorter.getSortableProperties(orama.data.sorting);
+  const sortablePropertiesWithTypes = await orama.sorter.getSortablePropertiesWithTypes(orama.data.sorting);
+  const sortableValues = await orama.getDocumentProperties(doc, sortableProperties);
+  for (const prop of sortableProperties) {
+    const value = sortableValues[prop];
     if (typeof value === "undefined") {
       continue;
     }
-    await ((_orama_index_beforeInsert = (_orama_index = orama.index).beforeInsert) === null || _orama_index_beforeInsert === void 0 ? void 0 : _orama_index_beforeInsert.call(_orama_index, orama.data.index, prop, id, value, language, orama.tokenizer, docsCount));
-    await orama.index.insert(orama.index, orama.data.index, prop, id, value, language, orama.tokenizer, docsCount);
-    await ((_orama_index_afterInsert = (_orama_index1 = orama.index).afterInsert) === null || _orama_index_afterInsert === void 0 ? void 0 : _orama_index_afterInsert.call(_orama_index1, orama.data.index, prop, id, value, language, orama.tokenizer, docsCount));
+    const expectedType = sortablePropertiesWithTypes[prop];
+    await orama.sorter.insert(orama.data.sorting, prop, id, value, expectedType, language);
   }
   if (!skipHooks) {
     await runSingleHook(orama.afterInsert, orama, id, doc);
@@ -4921,37 +3101,52 @@ async function insert4(orama, doc, language, skipHooks) {
   return id;
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.0.0-beta.16/node_modules/@orama/orama/dist/methods/remove.js
-async function remove4(orama, id, language, skipHooks) {
+// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/methods/remove.js
+async function remove5(orama, id, language, skipHooks) {
   let result = true;
   const { index, docs } = orama.data;
   const doc = await orama.documentsStore.get(docs, id);
   if (!doc) {
-    throw createError("DOCUMENT_DOES_NOT_EXIST", id);
+    return false;
   }
+  const docId = getDocumentIdFromInternalId(orama.internalDocumentIDStore, getInternalDocumentId(orama.internalDocumentIDStore, id));
   const docsCount = await orama.documentsStore.count(docs);
   if (!skipHooks) {
-    await runSingleHook(orama.beforeRemove, orama, id);
+    await runSingleHook(orama.beforeRemove, orama, docId);
   }
   const indexableProperties = await orama.index.getSearchableProperties(index);
+  const indexablePropertiesWithTypes = await orama.index.getSearchablePropertiesWithTypes(index);
   const values = await orama.getDocumentProperties(doc, indexableProperties);
   for (const prop of indexableProperties) {
     var _orama_index, _orama_index_beforeRemove, _orama_index1, _orama_index_afterRemove;
     const value = values[prop];
-    await ((_orama_index_beforeRemove = (_orama_index = orama.index).beforeRemove) === null || _orama_index_beforeRemove === void 0 ? void 0 : _orama_index_beforeRemove.call(_orama_index, orama.data.index, prop, id, value, language, orama.tokenizer, docsCount));
-    if (!await orama.index.remove(orama.index, orama.data.index, prop, id, value, language, orama.tokenizer, docsCount)) {
+    if (typeof value === "undefined") {
+      continue;
+    }
+    const schemaType = indexablePropertiesWithTypes[prop];
+    await ((_orama_index_beforeRemove = (_orama_index = orama.index).beforeRemove) === null || _orama_index_beforeRemove === void 0 ? void 0 : _orama_index_beforeRemove.call(_orama_index, orama.data.index, prop, docId, value, schemaType, language, orama.tokenizer, docsCount));
+    if (!await orama.index.remove(orama.index, orama.data.index, prop, id, value, schemaType, language, orama.tokenizer, docsCount)) {
       result = false;
     }
-    await ((_orama_index_afterRemove = (_orama_index1 = orama.index).afterRemove) === null || _orama_index_afterRemove === void 0 ? void 0 : _orama_index_afterRemove.call(_orama_index1, orama.data.index, prop, id, value, language, orama.tokenizer, docsCount));
+    await ((_orama_index_afterRemove = (_orama_index1 = orama.index).afterRemove) === null || _orama_index_afterRemove === void 0 ? void 0 : _orama_index_afterRemove.call(_orama_index1, orama.data.index, prop, docId, value, schemaType, language, orama.tokenizer, docsCount));
+  }
+  const sortableProperties = await orama.sorter.getSortableProperties(orama.data.sorting);
+  const sortableValues = await orama.getDocumentProperties(doc, sortableProperties);
+  for (const prop of sortableProperties) {
+    if (typeof sortableValues[prop] === "undefined") {
+      continue;
+    }
+    await orama.sorter.remove(orama.data.sorting, prop, id);
   }
   if (!skipHooks) {
-    await runSingleHook(orama.afterRemove, orama, id);
+    await runSingleHook(orama.afterRemove, orama, docId);
   }
+  await orama.documentsStore.remove(orama.data.docs, id);
   trackRemoval(orama);
   return result;
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.0.0-beta.16/node_modules/@orama/orama/dist/components/facets.js
+// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/components/facets.js
 function sortingPredicate(order = "desc", a, b) {
   if (order.toLowerCase() === "asc") {
     return a[1] - b[1];
@@ -4960,7 +3155,7 @@ function sortingPredicate(order = "desc", a, b) {
   }
 }
 async function getFacets(orama, results, facetsConfig) {
-  var _a2, _b, _c, _d;
+  var _a2, _b;
   const facets = {};
   const allIDs = results.map(([id]) => id);
   const allDocs = await orama.documentsStore.getMultiple(orama.data.docs, allIDs);
@@ -4989,19 +3184,35 @@ async function getFacets(orama, results, facetsConfig) {
     const doc = allDocs[i];
     for (const facet of facetKeys) {
       const facetValue = facet.includes(".") ? await getNested(doc, facet) : doc[facet];
-      if (properties[facet] === "number") {
-        for (const range of facetsConfig[facet].ranges) {
-          if (facetValue >= range.from && facetValue <= range.to) {
-            if (facets[facet].values[`${range.from}-${range.to}`] === void 0) {
-              facets[facet].values[`${range.from}-${range.to}`] = 1;
-            } else {
-              facets[facet].values[`${range.from}-${range.to}`]++;
-            }
+      const propertyType = properties[facet];
+      switch (propertyType) {
+        case "number": {
+          const ranges = facetsConfig[facet].ranges;
+          calculateNumberFacet(ranges, facets[facet].values, facetValue);
+          break;
+        }
+        case "number[]": {
+          const alreadyInsertedValues = /* @__PURE__ */ new Set();
+          const ranges = facetsConfig[facet].ranges;
+          for (const v2 of facetValue) {
+            calculateNumberFacet(ranges, facets[facet].values, v2, alreadyInsertedValues);
           }
+          break;
+        }
+        case "boolean":
+        case "string": {
+          calculateBooleanOrStringFacet(facets[facet].values, facetValue, propertyType);
+          break;
+        }
+        case "boolean[]":
+        case "string[]": {
+          const alreadyInsertedValues = /* @__PURE__ */ new Set();
+          const innerType = propertyType === "boolean[]" ? "boolean" : "string";
+          for (const v2 of facetValue) {
+            calculateBooleanOrStringFacet(facets[facet].values, v2, innerType, alreadyInsertedValues);
+          }
+          break;
         }
-      } else {
-        const value = (_a2 = facetValue === null || facetValue === void 0 ? void 0 : facetValue.toString()) != null ? _a2 : properties[facet] === "boolean" ? "false" : "";
-        facets[facet].values[value] = ((_b = facets[facet].values[value]) != null ? _b : 0) + 1;
       }
     }
   }
@@ -5009,13 +3220,42 @@ async function getFacets(orama, results, facetsConfig) {
     facets[facet].count = Object.keys(facets[facet].values).length;
     if (properties[facet] === "string") {
       const stringFacetDefinition = facetsConfig;
-      facets[facet].values = Object.fromEntries(Object.entries(facets[facet].values).sort((a, b) => sortingPredicate(stringFacetDefinition.sort, a, b)).slice((_c = stringFacetDefinition.offset) != null ? _c : 0, (_d = stringFacetDefinition.limit) != null ? _d : 10));
+      facets[facet].values = Object.fromEntries(Object.entries(facets[facet].values).sort((a, b) => sortingPredicate(stringFacetDefinition.sort, a, b)).slice((_a2 = stringFacetDefinition.offset) != null ? _a2 : 0, (_b = stringFacetDefinition.limit) != null ? _b : 10));
     }
   }
   return facets;
 }
+function calculateNumberFacet(ranges, values, facetValue, alreadyInsertedValues) {
+  for (const range of ranges) {
+    const value = `${range.from}-${range.to}`;
+    if (alreadyInsertedValues && alreadyInsertedValues.has(value)) {
+      continue;
+    }
+    if (facetValue >= range.from && facetValue <= range.to) {
+      if (values[value] === void 0) {
+        values[value] = 1;
+      } else {
+        values[value]++;
+        if (alreadyInsertedValues) {
+          alreadyInsertedValues.add(value);
+        }
+      }
+    }
+  }
+}
+function calculateBooleanOrStringFacet(values, facetValue, propertyType, alreadyInsertedValues) {
+  var _a2, _b;
+  const value = (_a2 = facetValue === null || facetValue === void 0 ? void 0 : facetValue.toString()) != null ? _a2 : propertyType === "boolean" ? "false" : "";
+  if (alreadyInsertedValues && alreadyInsertedValues.has(value)) {
+    return;
+  }
+  values[value] = ((_b = values[value]) != null ? _b : 0) + 1;
+  if (alreadyInsertedValues) {
+    alreadyInsertedValues.add(value);
+  }
+}
 
-// ../../node_modules/.pnpm/@orama+orama@1.0.0-beta.16/node_modules/@orama/orama/dist/components/filters.js
+// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/components/filters.js
 function intersectFilteredIDs(filtered, lookedUp) {
   const map = /* @__PURE__ */ new Map();
   const result = [];
@@ -5034,13 +3274,143 @@ function intersectFilteredIDs(filtered, lookedUp) {
   return result;
 }
 
-// ../../node_modules/.pnpm/@orama+orama@1.0.0-beta.16/node_modules/@orama/orama/dist/methods/search.js
+// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/components/groups.js
+var DEFAULT_REDUCE = {
+  reducer: (_, acc, res, index) => {
+    acc[index] = res;
+    return acc;
+  },
+  getInitialValue: (length) => Array.from({
+    length
+  })
+};
+var ALLOWED_TYPES = [
+  "string",
+  "number",
+  "boolean"
+];
+async function getGroups(orama, results, groupBy) {
+  const properties = groupBy.properties;
+  const propertiesLength = properties.length;
+  const schemaProperties = await orama.index.getSearchablePropertiesWithTypes(orama.data.index);
+  for (let i = 0; i < propertiesLength; i++) {
+    const property = properties[i];
+    if (typeof schemaProperties[property] === "undefined") {
+      throw createError("UNKNOWN_GROUP_BY_PROPERTY", property);
+    }
+    if (!ALLOWED_TYPES.includes(schemaProperties[property])) {
+      throw createError("INVALID_GROUP_BY_PROPERTY", property, ALLOWED_TYPES.join(", "), schemaProperties[property]);
+    }
+  }
+  const allIDs = results.map(([id]) => getDocumentIdFromInternalId(orama.internalDocumentIDStore, id));
+  const allDocs = await orama.documentsStore.getMultiple(orama.data.docs, allIDs);
+  const allDocsLength = allDocs.length;
+  const returnedCount = groupBy.maxResult || Number.MAX_SAFE_INTEGER;
+  const listOfValues = [];
+  const g = {};
+  for (let i = 0; i < propertiesLength; i++) {
+    const groupByKey = properties[i];
+    const group = {
+      property: groupByKey,
+      perValue: {}
+    };
+    const values = /* @__PURE__ */ new Set();
+    for (let j = 0; j < allDocsLength; j++) {
+      const doc = allDocs[j];
+      const value = await getNested(doc, groupByKey);
+      if (typeof value === "undefined") {
+        continue;
+      }
+      const keyValue = typeof value !== "boolean" ? value : "" + value;
+      if (typeof group.perValue[keyValue] === "undefined") {
+        group.perValue[keyValue] = {
+          indexes: [],
+          count: 0
+        };
+      }
+      if (group.perValue[keyValue].count >= returnedCount) {
+        continue;
+      }
+      group.perValue[keyValue].indexes.push(j);
+      group.perValue[keyValue].count++;
+      values.add(value);
+    }
+    listOfValues.push(Array.from(values));
+    g[groupByKey] = group;
+  }
+  const combinations = calculateCombination(listOfValues);
+  const combinationsLength = combinations.length;
+  const groups = [];
+  for (let i = 0; i < combinationsLength; i++) {
+    const combination = combinations[i];
+    const combinationLength = combination.length;
+    const group = {
+      values: [],
+      indexes: []
+    };
+    const indexes = [];
+    for (let j = 0; j < combinationLength; j++) {
+      const value = combination[j];
+      const property = properties[j];
+      indexes.push(g[property].perValue[typeof value !== "boolean" ? value : "" + value].indexes);
+      group.values.push(value);
+    }
+    group.indexes = intersect(indexes).sort((a, b) => a - b);
+    if (group.indexes.length === 0) {
+      continue;
+    }
+    groups.push(group);
+  }
+  const groupsLength = groups.length;
+  const res = Array.from({
+    length: groupsLength
+  });
+  for (let i = 0; i < groupsLength; i++) {
+    const group = groups[i];
+    const reduce = groupBy.reduce || DEFAULT_REDUCE;
+    const docs = group.indexes.map((index) => {
+      return {
+        id: allIDs[index],
+        score: results[index][1],
+        document: allDocs[index]
+      };
+    });
+    const func = reduce.reducer.bind(null, group.values);
+    const initialValue = reduce.getInitialValue(group.indexes.length);
+    const aggregationValue = docs.reduce(func, initialValue);
+    res[i] = {
+      values: group.values,
+      result: aggregationValue
+    };
+  }
+  return res;
+}
+function calculateCombination(arrs, index = 0) {
+  if (index + 1 === arrs.length)
+    return arrs[index].map((item) => [
+      item
+    ]);
+  const head = arrs[index];
+  const c2 = calculateCombination(arrs, index + 1);
+  const combinations = [];
+  for (const value of head) {
+    for (const combination of c2) {
+      combinations.push([
+        value,
+        ...combination
+      ]);
+    }
+  }
+  return combinations;
+}
+
+// ../../node_modules/.pnpm/@orama+orama@1.1.1/node_modules/@orama/orama/dist/methods/search.js
 var defaultBM25Params = {
   k: 1.2,
   b: 0.75,
   d: 0.5
 };
-async function createSearchContext(tokenizer, index, documentsStore, language, params, properties, tokens, docsCount) {
+async function createSearchContext(tokenizer, index, documentsStore, language, params, properties, tokens, docsCount, timeStart) {
   const indexMap = {};
   const docsIntersection = {};
   for (const prop of properties) {
@@ -5052,7 +3422,7 @@ async function createSearchContext(tokenizer, index, documentsStore, language, p
     docsIntersection[prop] = [];
   }
   return {
-    timeStart: await getNanosecondsTime(),
+    timeStart,
     tokenizer,
     index,
     documentsStore,
@@ -5066,9 +3436,10 @@ async function createSearchContext(tokenizer, index, documentsStore, language, p
 }
 async function search2(orama, params, language) {
   var _a2, _b, _c;
+  const timeStart = await getNanosecondsTime();
   params.relevance = Object.assign((_a2 = params.relevance) != null ? _a2 : {}, defaultBM25Params);
   const shouldCalculateFacets = params.facets && Object.keys(params.facets).length > 0;
-  const { limit = 10, offset = 0, term, properties, threshold = 1 } = params;
+  const { limit = 10, offset = 0, term, properties, threshold = 1, distinctOn } = params;
   const isPreflight = params.preflight === true;
   const { index, docs } = orama.data;
   const tokens = await orama.tokenizer.tokenize(term != null ? term : "", language);
@@ -5076,7 +3447,7 @@ async function search2(orama, params, language) {
   if (!propertiesToSearch) {
     const propertiesToSearchWithTypes = await orama.index.getSearchablePropertiesWithTypes(index);
     propertiesToSearch = await orama.index.getSearchableProperties(index);
-    propertiesToSearch = propertiesToSearch.filter((prop) => propertiesToSearchWithTypes[prop] === "string");
+    propertiesToSearch = propertiesToSearch.filter((prop) => propertiesToSearchWithTypes[prop].startsWith("string"));
     orama.caches["propertiesToSearch"] = propertiesToSearch;
   }
   if (properties && properties !== "*") {
@@ -5087,29 +3458,27 @@ async function search2(orama, params, language) {
     }
     propertiesToSearch = propertiesToSearch.filter((prop) => properties.includes(prop));
   }
-  const context = await createSearchContext(orama.tokenizer, orama.index, orama.documentsStore, language, params, propertiesToSearch, tokens, await orama.documentsStore.count(docs));
-  const results = Array.from({
-    length: limit
-  });
+  const context = await createSearchContext(orama.tokenizer, orama.index, orama.documentsStore, language, params, propertiesToSearch, tokens, await orama.documentsStore.count(docs), timeStart);
   const hasFilters = Object.keys((_b = params.where) != null ? _b : {}).length > 0;
   let whereFiltersIDs = [];
   if (hasFilters) {
     whereFiltersIDs = await orama.index.searchByWhereClause(context, index, params.where);
   }
-  if (tokens.length) {
+  const tokensLength = tokens.length;
+  if (tokensLength) {
     const indexesLength = propertiesToSearch.length;
     for (let i = 0; i < indexesLength; i++) {
       var _params_boost;
       const prop = propertiesToSearch[i];
-      const tokensLength = tokens.length;
-      for (let j = 0; j < tokensLength; j++) {
+      const tokensLength2 = tokens.length;
+      for (let j = 0; j < tokensLength2; j++) {
         const term2 = tokens[j];
         const scoreList = await orama.index.search(context, index, prop, term2);
         context.indexMap[prop][term2].push(...scoreList);
       }
       const docIds = context.indexMap[prop];
       const vals = Object.values(docIds);
-      context.docsIntersection[prop] = prioritizeTokenScores(vals, (_c = params === null || params === void 0 ? void 0 : (_params_boost = params.boost) === null || _params_boost === void 0 ? void 0 : _params_boost[prop]) != null ? _c : 1, threshold);
+      context.docsIntersection[prop] = prioritizeTokenScores(vals, (_c = params === null || params === void 0 ? void 0 : (_params_boost = params.boost) === null || _params_boost === void 0 ? void 0 : _params_boost[prop]) != null ? _c : 1, threshold, tokensLength2);
       const uniqueDocs = context.docsIntersection[prop];
       const uniqueDocsLength = uniqueDocs.length;
       for (let i2 = 0; i2 < uniqueDocsLength; i2++) {
@@ -5122,49 +3491,136 @@ async function search2(orama, params, language) {
         }
       }
     }
+  } else if (tokens.length === 0 && term) {
+    context.uniqueDocsIDs = {};
   } else {
     context.uniqueDocsIDs = Object.fromEntries(Object.keys(await orama.documentsStore.getAll(orama.data.docs)).map((k) => [
       k,
       0
     ]));
   }
-  let uniqueDocsArray = Object.entries(context.uniqueDocsIDs).sort(sortTokenScorePredicate);
+  let uniqueDocsArray = Object.entries(context.uniqueDocsIDs).map(([id, score]) => [
+    +id,
+    score
+  ]);
   if (hasFilters) {
     uniqueDocsArray = intersectFilteredIDs(whereFiltersIDs, uniqueDocsArray);
   }
-  const resultIDs = /* @__PURE__ */ new Set();
-  const facets = shouldCalculateFacets ? await getFacets(orama, uniqueDocsArray, params.facets) : {};
-  if (!isPreflight) {
-    for (let i = offset; i < limit + offset; i++) {
-      const idAndScore = uniqueDocsArray[i];
-      if (typeof idAndScore === "undefined") {
-        break;
-      }
-      const [id, score] = idAndScore;
-      if (!resultIDs.has(id)) {
-        const fullDoc = await orama.documentsStore.get(docs, id);
-        results[i] = {
-          id,
-          score,
-          document: fullDoc
-        };
-        resultIDs.add(id);
-      }
+  if (params.sortBy) {
+    if (typeof params.sortBy === "function") {
+      const ids = uniqueDocsArray.map(([id]) => id);
+      const docs2 = await orama.documentsStore.getMultiple(orama.data.docs, ids);
+      const docsWithIdAndScore = docs2.map((d, i) => [
+        uniqueDocsArray[i][0],
+        uniqueDocsArray[i][1],
+        d
+      ]);
+      docsWithIdAndScore.sort(params.sortBy);
+      uniqueDocsArray = docsWithIdAndScore.map(([id, score]) => [
+        id,
+        score
+      ]);
+    } else {
+      uniqueDocsArray = await orama.sorter.sortBy(orama.data.sorting, uniqueDocsArray, params.sortBy).then((results2) => results2.map(([id, score]) => [
+        getInternalDocumentId(orama.internalDocumentIDStore, id),
+        score
+      ]));
     }
+  } else {
+    uniqueDocsArray = uniqueDocsArray.sort(sortTokenScorePredicate);
+  }
+  let results;
+  if (!isPreflight && distinctOn) {
+    results = await fetchDocumentsWithDistinct(orama, uniqueDocsArray, offset, limit, distinctOn);
+  } else if (!isPreflight) {
+    results = await fetchDocuments(orama, uniqueDocsArray, offset, limit);
   }
   const searchResult = {
-    elapsed: await orama.formatElapsedTime(await getNanosecondsTime() - context.timeStart),
+    elapsed: {
+      formatted: "",
+      raw: 0
+    },
     hits: [],
     count: uniqueDocsArray.length
   };
-  if (!isPreflight) {
+  if (typeof results !== "undefined") {
     searchResult.hits = results.filter(Boolean);
   }
   if (shouldCalculateFacets) {
+    const facets = await getFacets(orama, uniqueDocsArray, params.facets);
     searchResult.facets = facets;
   }
+  if (params.groupBy) {
+    searchResult.groups = await getGroups(orama, uniqueDocsArray, params.groupBy);
+  }
+  if (orama.afterSearch) {
+    await runAfterSearch(orama.afterSearch, orama, params, language, searchResult);
+  }
+  searchResult.elapsed = await orama.formatElapsedTime(await getNanosecondsTime() - context.timeStart);
   return searchResult;
 }
+async function fetchDocumentsWithDistinct(orama, uniqueDocsArray, offset, limit, distinctOn) {
+  const docs = orama.data.docs;
+  const values = /* @__PURE__ */ new Map();
+  const results = [];
+  const resultIDs = /* @__PURE__ */ new Set();
+  const uniqueDocsArrayLength = uniqueDocsArray.length;
+  let count2 = 0;
+  for (let i = 0; i < uniqueDocsArrayLength; i++) {
+    const idAndScore = uniqueDocsArray[i];
+    if (typeof idAndScore === "undefined") {
+      continue;
+    }
+    const [id, score] = idAndScore;
+    if (resultIDs.has(id)) {
+      continue;
+    }
+    const doc = await orama.documentsStore.get(docs, id);
+    const value = await getNested(doc, distinctOn);
+    if (typeof value === "undefined" || values.has(value)) {
+      continue;
+    }
+    values.set(value, true);
+    count2++;
+    if (count2 <= offset) {
+      continue;
+    }
+    results.push({
+      id: getDocumentIdFromInternalId(orama.internalDocumentIDStore, id),
+      score,
+      document: doc
+    });
+    resultIDs.add(id);
+    if (count2 >= offset + limit) {
+      break;
+    }
+  }
+  return results;
+}
+async function fetchDocuments(orama, uniqueDocsArray, offset, limit) {
+  const docs = orama.data.docs;
+  const results = Array.from({
+    length: limit
+  });
+  const resultIDs = /* @__PURE__ */ new Set();
+  for (let i = offset; i < limit + offset; i++) {
+    const idAndScore = uniqueDocsArray[i];
+    if (typeof idAndScore === "undefined") {
+      break;
+    }
+    const [id, score] = idAndScore;
+    if (!resultIDs.has(id)) {
+      const fullDoc = await orama.documentsStore.get(docs, id);
+      results[i] = {
+        id: getDocumentIdFromInternalId(orama.internalDocumentIDStore, id),
+        score,
+        document: fullDoc
+      };
+      resultIDs.add(id);
+    }
+  }
+  return results;
+}
 
 // src/indexer.ts
 var import_debug = __toESM(require_src());
@@ -5189,7 +3645,7 @@ var SearchMemoryIndexer = class {
     if (this.database) {
       const name = pkg.name;
       debug("adding item %s to the indexer", name);
-      insert4(this.database, {
+      insert5(this.database, {
         id: name,
         name,
         description: pkg.description,
@@ -5202,7 +3658,7 @@ var SearchMemoryIndexer = class {
   async remove(name) {
     if (this.database) {
       debug("removing item %s to the indexer", name);
-      await remove4(this.database, name);
+      await remove5(this.database, name);
     }
   }
   reindex() {
@@ -5225,7 +3681,7 @@ var SearchMemoryIndexer = class {
     });
   }
   async init() {
-    this.database = await create5({
+    this.database = await create6({
       schema: {
         id: "string",
         name: "string",