@pol-studios/db 1.0.47 → 1.0.48

package/dist/{chunk-AKIRHA4Q.js → chunk-UJWETW36.js}

@@ -1,11 +1,15 @@
+import {
+  deepEqual,
+  flatten
+} from "./chunk-INEUG6MC.js";
 import {
   __commonJS,
   __toESM
 } from "./chunk-7D4SUZUM.js";
 
-// ../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/tools/output/categories.js
+// ../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/tools/output/categories.js
 var require_categories = __commonJS({
-  "../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/tools/output/categories.js"(exports, module) {
+  "../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/tools/output/categories.js"(exports, module) {
     module.exports = [
       {
         "name": "C",
@@ -227,9 +231,9 @@ var require_categories = __commonJS({
   }
 });
 
-// ../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/tools/output/properties.js
+// ../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/tools/output/properties.js
 var require_properties = __commonJS({
-  "../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/tools/output/properties.js"(exports, module) {
+  "../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/tools/output/properties.js"(exports, module) {
     module.exports = [
       {
         "name": "ASCII",
@@ -274,9 +278,9 @@ var require_properties = __commonJS({
   }
 });
 
-// ../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/tools/output/scripts.js
+// ../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/tools/output/scripts.js
 var require_scripts = __commonJS({
-  "../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/tools/output/scripts.js"(exports, module) {
+  "../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/tools/output/scripts.js"(exports, module) {
     module.exports = [
       {
         "name": "Adlam",
@@ -942,15 +946,90 @@ var require_scripts = __commonJS({
   }
 });
 
-// ../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/src/xregexp.js
+// src/parser/lib/sort-search-param.ts
+var sortSearchParams = (params) => new URLSearchParams(Array.from(params.entries()).sort((a, b) => {
+  const x = `${a[0]}${a[1]}`;
+  const y = `${b[0]}${b[1]}`;
+  return x > y ? 1 : -1;
+}));
+
+// src/parser/lib/encode-object.ts
+var encodeObject = (obj) => {
+  const sortedEntries = Object.entries(flatten(obj)).sort(([a], [b]) => a.length - b.length);
+  const bodyParams = new URLSearchParams();
+  sortedEntries.forEach(([key, value]) => {
+    bodyParams.append(key, String(value));
+  });
+  return sortSearchParams(bodyParams).toString();
+};
+
+// src/parser/lib/is-object.ts
+var isObject = (v) => typeof v === "object" && !Array.isArray(v) && v !== null;
+
+// src/parser/lib/find-last-index.ts
+function findLastIndex(array, predicate) {
+  let l = array.length;
+  while (l--) {
+    if (predicate(array[l], l, array)) return l;
+  }
+  return -1;
+}
+
+// src/parser/lib/is-not-null.ts
+var isNotNull = (i) => i !== null;
+
+// src/parser/lib/operators.ts
+var buildLikeRegex = (search) => new RegExp(`^${search.replace(/%/g, ".*")}$`);
+var textSearch = (c, v) => {
+  const regExp = `^${v.split("&").map((v2) => v2.trim().toLowerCase()).join("|").replace(/:\*/g, ".*")}$`;
+  const tokens2 = c.match(/'(.*?)'/g).map((t) => t.replace(/'/g, "").toLowerCase());
+  return tokens2.some((t) => new RegExp(regExp).test(t));
+};
+var ifDateGetTime = (v) => v instanceof Date ? v.getTime() : v;
+var enclose = (v, char) => {
+  if (!v.startsWith(char)) v = `${char}${v}`;
+  if (!v.endsWith(char)) v = `${v}${char}`;
+  return v;
+};
+var OPERATOR_MAP = {
+  eq: (c, v) => ifDateGetTime(c) === ifDateGetTime(v),
+  neq: (c, v) => ifDateGetTime(c) !== ifDateGetTime(v),
+  gt: (c, v) => c > v,
+  gte: (c, v) => c >= v,
+  lt: (c, v) => c < v,
+  lte: (c, v) => c <= v,
+  like: (c, v) => buildLikeRegex(v).test(c.toString()),
+  ilike: (c, v) => buildLikeRegex(v.toLowerCase()).test(c.toString().toLowerCase()),
+  is: (c, v) => c === v,
+  in: (c, v) => {
+    const parsedValue = v.slice(1, -1).split(",");
+    return parsedValue.some((i) => i === c);
+  },
+  // contains
+  cs: (c, v) => {
+    if (!Array.isArray(c)) return false;
+    if (!Array.isArray(v)) v = v.slice(1, -1).split(",");
+    return v.every((i) => c.some((colVal) => deepEqual(colVal, i)));
+  },
+  // containedBy
+  cd: (c, v) => {
+    if (!Array.isArray(c)) return false;
+    if (!Array.isArray(v)) v = v.slice(1, -1).split(",");
+    return c.every((i) => v.some((cmpVal) => deepEqual(cmpVal, i)));
+  },
+  fts: textSearch,
+  plfts: (c, v) => buildLikeRegex(enclose(v.toLowerCase(), "%")).test(c.toString().toLowerCase())
+};
+
+// ../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/src/xregexp.js
 var REGEX_DATA = "xregexp";
 var features = {
   astral: false,
   namespacing: true
 };
 var fixed = {};
-var regexCache = {};
-var patternCache = {};
+var regexCache = /* @__PURE__ */ Object.create(null);
+var patternCache = /* @__PURE__ */ Object.create(null);
 var tokens = [];
 var defaultScope = "default";
 var classScope = "class";
@@ -1256,7 +1335,7 @@ function XRegExp(pattern, flags) {
   );
 }
 XRegExp.prototype = new RegExp();
-XRegExp.version = "5.1.1";
+XRegExp.version = "5.1.2";
 XRegExp._clipDuplicates = clipDuplicates;
 XRegExp._hasNativeFlag = hasNativeFlag;
 XRegExp._dec = dec;
@@ -1296,9 +1375,9 @@ XRegExp.cache = (pattern, flags) => {
 };
 XRegExp.cache.flush = (cacheName) => {
   if (cacheName === "patterns") {
-    patternCache = {};
+    patternCache = /* @__PURE__ */ Object.create(null);
   } else {
-    regexCache = {};
+    regexCache = /* @__PURE__ */ Object.create(null);
   }
 };
 XRegExp.escape = (str) => String(nullThrows(str)).replace(/[\\\[\]{}()*+?.^$|]/g, "\\$&").replace(/[\s#\-,]/g, (match) => `\\u${pad4(hex(match.charCodeAt(0)))}`);
@@ -1751,7 +1830,7 @@ XRegExp.addToken(
 );
 var xregexp_default = XRegExp;
 
-// ../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/src/addons/build.js
+// ../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/src/addons/build.js
 var build_default = (XRegExp2) => {
   const REGEX_DATA2 = "xregexp";
   const subParts = /(\()(?!\?)|\\([1-9]\d*)|\\[\s\S]|\[(?:[^\\\]]|\\[\s\S])*\]/g;
@@ -1875,7 +1954,7 @@ var build_default = (XRegExp2) => {
   };
 };
 
-// ../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/src/addons/matchrecursive.js
+// ../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/src/addons/matchrecursive.js
 var matchrecursive_default = (XRegExp2) => {
   function row(name, value, start, end) {
     return {
@@ -2005,7 +2084,7 @@ var matchrecursive_default = (XRegExp2) => {
   };
 };
 
-// ../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/src/addons/unicode-base.js
+// ../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/src/addons/unicode-base.js
 var unicode_base_default = (XRegExp2) => {
   const unicode = {};
   const unicodeTypes = {};
@@ -2157,7 +2236,7 @@ var unicode_base_default = (XRegExp2) => {
   };
 };
 
-// ../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/src/addons/unicode-categories.js
+// ../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/src/addons/unicode-categories.js
 var import_categories = __toESM(require_categories());
 var unicode_categories_default = (XRegExp2) => {
   if (!XRegExp2.addUnicodeData) {
@@ -2166,7 +2245,7 @@ var unicode_categories_default = (XRegExp2) => {
   XRegExp2.addUnicodeData(import_categories.default);
 };
 
-// ../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/src/addons/unicode-properties.js
+// ../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/src/addons/unicode-properties.js
 var import_properties = __toESM(require_properties());
 var unicode_properties_default = (XRegExp2) => {
   if (!XRegExp2.addUnicodeData) {
@@ -2182,7 +2261,7 @@ var unicode_properties_default = (XRegExp2) => {
   XRegExp2.addUnicodeData(unicodeData);
 };
 
-// ../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/src/addons/unicode-scripts.js
+// ../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/src/addons/unicode-scripts.js
 var import_scripts = __toESM(require_scripts());
 var unicode_scripts_default = (XRegExp2) => {
   if (!XRegExp2.addUnicodeData) {
@@ -2191,7 +2270,7 @@ var unicode_scripts_default = (XRegExp2) => {
   XRegExp2.addUnicodeData(import_scripts.default, "Script");
 };
 
-// ../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/src/index.js
+// ../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/src/index.js
 build_default(xregexp_default);
 matchrecursive_default(xregexp_default);
 unicode_base_default(xregexp_default);
@@ -2200,560 +2279,372 @@ unicode_properties_default(xregexp_default);
 unicode_scripts_default(xregexp_default);
 var src_default = xregexp_default;
 
-// ../../../node_modules/.pnpm/flat@6.0.1/node_modules/flat/index.js
-function isBuffer(obj) {
-  return obj && obj.constructor && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj);
-}
-function keyIdentity(key) {
-  return key;
-}
-function flatten(target, opts) {
-  opts = opts || {};
-  const delimiter = opts.delimiter || ".";
-  const maxDepth = opts.maxDepth;
-  const transformKey = opts.transformKey || keyIdentity;
-  const output = {};
-  function step(object, prev, currentDepth) {
-    currentDepth = currentDepth || 1;
-    Object.keys(object).forEach(function(key) {
-      const value = object[key];
-      const isarray = opts.safe && Array.isArray(value);
-      const type = Object.prototype.toString.call(value);
-      const isbuffer = isBuffer(value);
-      const isobject = type === "[object Object]" || type === "[object Array]";
-      const newKey = prev ? prev + delimiter + transformKey(key) : transformKey(key);
-      if (!isarray && !isbuffer && isobject && Object.keys(value).length && (!opts.maxDepth || currentDepth < maxDepth)) {
-        return step(value, newKey, currentDepth + 1);
-      }
-      output[newKey] = value;
-    });
-  }
-  step(target);
-  return output;
-}
-function unflatten(target, opts) {
-  opts = opts || {};
-  const delimiter = opts.delimiter || ".";
-  const overwrite = opts.overwrite || false;
-  const transformKey = opts.transformKey || keyIdentity;
-  const result = {};
-  const isbuffer = isBuffer(target);
-  if (isbuffer || Object.prototype.toString.call(target) !== "[object Object]") {
-    return target;
-  }
-  function getkey(key) {
-    const parsedKey = Number(key);
-    return isNaN(parsedKey) || key.indexOf(".") !== -1 || opts.object ? key : parsedKey;
-  }
-  function addKeys(keyPrefix, recipient, target2) {
-    return Object.keys(target2).reduce(function(result2, key) {
-      result2[keyPrefix + delimiter + key] = target2[key];
-      return result2;
-    }, recipient);
-  }
-  function isEmpty(val) {
-    const type = Object.prototype.toString.call(val);
-    const isArray2 = type === "[object Array]";
-    const isObject = type === "[object Object]";
-    if (!val) {
-      return true;
-    } else if (isArray2) {
-      return !val.length;
-    } else if (isObject) {
-      return !Object.keys(val).length;
-    }
-  }
-  target = Object.keys(target).reduce(function(result2, key) {
-    const type = Object.prototype.toString.call(target[key]);
-    const isObject = type === "[object Object]" || type === "[object Array]";
-    if (!isObject || isEmpty(target[key])) {
-      result2[key] = target[key];
-      return result2;
-    } else {
-      return addKeys(
-        key,
-        result2,
-        flatten(target[key], opts)
-      );
+// src/parser/lib/parse-select-param.ts
+var parseSelectParam = (s, currentPath) => {
+  s = s.replace(/\s/g, "");
+  const foreignTables = src_default.matchRecursive(`,${s}`, ",[^,]*\\(", "\\)", "g", {
+    valueNames: {
+      "0": null,
+      "1": "tableName",
+      "2": "selectedColumns",
+      "3": null
+    }
+  }).reduce((prev, curr, idx, matches) => {
+    if (curr.name === "selectedColumns") {
+      const name = matches[idx - 1].value.slice(1, -1);
+      prev = {
+        ...prev,
+        [name]: curr.value
+      };
     }
+    return prev;
   }, {});
-  Object.keys(target).forEach(function(key) {
-    const split = key.split(delimiter).map(transformKey);
-    let key1 = getkey(split.shift());
-    let key2 = getkey(split[0]);
-    let recipient = result;
-    while (key2 !== void 0) {
-      if (key1 === "__proto__") {
-        return;
-      }
-      const type = Object.prototype.toString.call(recipient[key1]);
-      const isobject = type === "[object Object]" || type === "[object Array]";
-      if (!overwrite && !isobject && typeof recipient[key1] !== "undefined") {
-        return;
-      }
-      if (overwrite && !isobject || !overwrite && recipient[key1] == null) {
-        recipient[key1] = typeof key2 === "number" && !opts.object ? [] : {};
-      }
-      recipient = recipient[key1];
-      if (split.length > 0) {
-        key1 = getkey(split.shift());
-        key2 = getkey(split[0]);
-      }
-    }
-    recipient[key1] = unflatten(target[key], opts);
+  const columns = s.replace(new RegExp(`${Object.entries(foreignTables).map(([table, selectedColumns]) => `${table}(${selectedColumns})`.replace(/\(/g, "\\(").replace(/\)/g, "\\)")).join("|")}`, "g"), "").replace(/(,)\1+/g, ",").split(",").filter((c) => c.length > 0).map((c) => {
+    const split = c.split(":");
+    const hasAlias = split.length > 1;
+    return {
+      declaration: [currentPath?.declaration, c].filter(Boolean).join("."),
+      alias: hasAlias || currentPath?.alias ? [currentPath?.alias ?? currentPath?.path, split[0]].filter(Boolean).join(".") : void 0,
+      path: [currentPath?.path, split[hasAlias ? 1 : 0]].filter(Boolean).join(".")
+    };
   });
-  return result;
-}
+  return [...columns, ...Object.entries(foreignTables).flatMap(([currentDeclaration, selectedColumns]) => {
+    const aliasSplit = currentDeclaration.split(":");
+    const currentAliasElem = aliasSplit.length > 1 ? aliasSplit[0] : void 0;
+    const currentPathDeclaration = aliasSplit[aliasSplit.length - 1];
+    const currentPathElem = currentPathDeclaration.split("!")[0];
+    const path = [currentPath?.path, currentPathElem].filter(Boolean).join(".");
+    const alias = [currentPath?.alias ?? currentPath?.path, currentAliasElem ?? currentPathElem].filter(Boolean).join(".");
+    const declaration = [currentPath?.declaration, currentDeclaration].filter(Boolean).join(".");
+    return parseSelectParam(`${selectedColumns}`, {
+      path,
+      alias: currentPath?.alias || currentAliasElem ? alias : void 0,
+      declaration
+    });
+  })];
+};
 
-// ../../../node_modules/.pnpm/fast-equals@5.2.2/node_modules/fast-equals/dist/esm/index.mjs
-var getOwnPropertyNames = Object.getOwnPropertyNames;
-var getOwnPropertySymbols = Object.getOwnPropertySymbols;
-var hasOwnProperty = Object.prototype.hasOwnProperty;
-function combineComparators(comparatorA, comparatorB) {
-  return function isEqual(a, b, state) {
-    return comparatorA(a, b, state) && comparatorB(a, b, state);
-  };
-}
-function createIsCircular(areItemsEqual) {
-  return function isCircular(a, b, state) {
-    if (!a || !b || typeof a !== "object" || typeof b !== "object") {
-      return areItemsEqual(a, b, state);
-    }
-    var cache = state.cache;
-    var cachedA = cache.get(a);
-    var cachedB = cache.get(b);
-    if (cachedA && cachedB) {
-      return cachedA === b && cachedB === a;
-    }
-    cache.set(a, b);
-    cache.set(b, a);
-    var result = areItemsEqual(a, b, state);
-    cache.delete(a);
-    cache.delete(b);
-    return result;
-  };
-}
-function getStrictProperties(object) {
-  return getOwnPropertyNames(object).concat(getOwnPropertySymbols(object));
-}
-var hasOwn = Object.hasOwn || (function(object, property) {
-  return hasOwnProperty.call(object, property);
-});
-function sameValueZeroEqual(a, b) {
-  return a === b || !a && !b && a !== a && b !== b;
-}
-var PREACT_VNODE = "__v";
-var PREACT_OWNER = "__o";
-var REACT_OWNER = "_owner";
-var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
-var keys = Object.keys;
-function areArraysEqual(a, b, state) {
-  var index = a.length;
-  if (b.length !== index) {
-    return false;
-  }
-  while (index-- > 0) {
-    if (!state.equals(a[index], b[index], index, index, a, b, state)) {
-      return false;
-    }
-  }
-  return true;
-}
-function areDatesEqual(a, b) {
-  return sameValueZeroEqual(a.getTime(), b.getTime());
-}
-function areErrorsEqual(a, b) {
-  return a.name === b.name && a.message === b.message && a.cause === b.cause && a.stack === b.stack;
-}
-function areFunctionsEqual(a, b) {
-  return a === b;
-}
-function areMapsEqual(a, b, state) {
-  var size = a.size;
-  if (size !== b.size) {
-    return false;
-  }
-  if (!size) {
-    return true;
-  }
-  var matchedIndices = new Array(size);
-  var aIterable = a.entries();
-  var aResult;
-  var bResult;
-  var index = 0;
-  while (aResult = aIterable.next()) {
-    if (aResult.done) {
-      break;
-    }
-    var bIterable = b.entries();
-    var hasMatch = false;
-    var matchIndex = 0;
-    while (bResult = bIterable.next()) {
-      if (bResult.done) {
-        break;
-      }
-      if (matchedIndices[matchIndex]) {
-        matchIndex++;
-        continue;
-      }
-      var aEntry = aResult.value;
-      var bEntry = bResult.value;
-      if (state.equals(aEntry[0], bEntry[0], index, matchIndex, a, b, state) && state.equals(aEntry[1], bEntry[1], aEntry[0], bEntry[0], a, b, state)) {
-        hasMatch = matchedIndices[matchIndex] = true;
-        break;
-      }
-      matchIndex++;
-    }
-    if (!hasMatch) {
-      return false;
-    }
-    index++;
+// src/parser/lib/is-iso-date-string.ts
+var isISODateString = (v) => typeof v === "string" && /(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))/.test(v);
+
+// src/parser/lib/parse-value.ts
+var parseValue = (v) => {
+  if (isISODateString(v)) return new Date(v);
+  try {
+    return JSON.parse(v);
+  } catch {
+    return v;
   }
-  return true;
-}
-var areNumbersEqual = sameValueZeroEqual;
-function areObjectsEqual(a, b, state) {
-  var properties2 = keys(a);
-  var index = properties2.length;
-  if (keys(b).length !== index) {
-    return false;
-  }
-  while (index-- > 0) {
-    if (!isPropertyEqual(a, b, state, properties2[index])) {
-      return false;
+};
+
+// src/parser/postgrest-query-parser.ts
+var SUPPORTED_OPERATORS = ["or", ...Object.keys(OPERATOR_MAP)];
+var PostgrestQueryParser = class {
+  constructor(query, opts) {
+    this.opts = opts;
+    this._params = new URLSearchParams(query);
+  }
+  _params;
+  _filters;
+  _paths;
+  /**
+   * Getter that returns the paths and their aliases that the query selects. Will do the computation only once.
+   *
+   * ```js
+   * const p = new PostgrestParser(
+   * supabaseClient.from("test")
+   *    .select(
+   *      `name,
+   *       city:cities (
+   *        test:name
+   *      ),
+   *      countries (
+   *        capital,
+   *        population,
+   *        some_ref (
+   *          test:first,
+   *          second
+   *        )
+   *      )`
+   *    );
+   * console.log(p.paths);
+   * //  [
+   * //    { alias: undefined, path: "name" },
+   * //    { alias: "city.test", path: "cities.name" },
+   * //    { alias: undefined, path: "countries.capital" },
+   * //    { alias: undefined, path: "countries.population" },
+   * //    {
+   * //      alias: "countries.some_ref.test",
+   * //      path: "countries.some_ref.first",
+   * //    },
+   * //    { alias: undefined, path: "countries.some_ref.second" },
+   * //  ];
+   * ```
+   *
+   * @returns an array of paths that the query selects, containing the columns and aliases
+   */
+  get paths() {
+    if (!this._paths) {
+      const select = this._params.get("select");
+      this._paths = select ? parseSelectParam(select) : [];
+    }
+    return this._paths;
+  }
+  /**
+   * Getter that returns the filters that this query applies in a json object.
+   *
+   * ```js
+   * const p = new PostgrestParser(
+   * supabaseClient.from("test").select('*')
+   *  .or("full_name.eq.20,test.neq.true,and(full_name.eq.Test Name,email.eq.test@mail.com)")
+   *  .eq("id", "123")
+   *  .contains("id", "456")
+   * );
+   *
+   * console.log(p.filters);
+   *
+   * // [
+   * //   {
+   * //     or: [
+   * //       {
+   * //         path: "full_name",
+   * //         negate: false,
+   * //         operator: "eq",
+   * //         value: 20,
+   * //       },
+   * //       {
+   * //         path: "test",
+   * //         negate: false,
+   * //         operator: "neq",
+   * //         value: true,
+   * //       },
+   * //       {
+   * //         and: [
+   * //           {
+   * //             path: "full_name",
+   * //             negate: false,
+   * //             operator: "eq",
+   * //             value: "Test Name",
+   * //           },
+   * //           {
+   * //             path: "email",
+   * //             negate: false,
+   * //             operator: "eq",
+   * //             value: "test@mail.com",
+   * //           },
+   * //         ],
+   * //       },
+   * //     ],
+   * //   },
+   * //   {
+   * //     path: "id",
+   * //     negate: false,
+   * //     operator: "eq",
+   * //     value: 123,
+   * //   },
+   * //   {
+   * //     path: "id",
+   * //     negate: false,
+   * //     operator: "cs",
+   * //     value: 456,
+   * //   },
+   * // ];
+   * ```
+   *
+   * @returns a FilterDefinitions object
+   */
+  get filters() {
+    if (!this._filters) {
+      const filters = [];
+      this._params.forEach((value, key) => {
+        if (SUPPORTED_OPERATORS.some((f) => key === f || value.split(".").includes(f))) {
+          const filter = this.parseFilterString(`${key}.${value}`, void 0);
+          if (filter !== null) filters.push(filter);
+        }
+      });
+      this._filters = filters;
     }
+    return this._filters;
   }
-  return true;
-}
-function areObjectsEqualStrict(a, b, state) {
-  var properties2 = getStrictProperties(a);
-  var index = properties2.length;
-  if (getStrictProperties(b).length !== index) {
-    return false;
-  }
-  var property;
-  var descriptorA;
-  var descriptorB;
-  while (index-- > 0) {
-    property = properties2[index];
-    if (!isPropertyEqual(a, b, state, property)) {
-      return false;
-    }
-    descriptorA = getOwnPropertyDescriptor(a, property);
-    descriptorB = getOwnPropertyDescriptor(b, property);
-    if ((descriptorA || descriptorB) && (!descriptorA || !descriptorB || descriptorA.configurable !== descriptorB.configurable || descriptorA.enumerable !== descriptorB.enumerable || descriptorA.writable !== descriptorB.writable)) {
-      return false;
+  parseFilterString(filter, prefix) {
+    if (filter.startsWith("and(") && filter.endsWith(")")) {
+      const andFilters = filter.slice(4, -1).split(",").map((s) => this.parseFilterString(s, prefix)).filter(isNotNull);
+      if (andFilters.length === 0) return null;
+      else return {
+        and: andFilters
+      };
     }
-  }
-  return true;
-}
-function arePrimitiveWrappersEqual(a, b) {
-  return sameValueZeroEqual(a.valueOf(), b.valueOf());
-}
-function areRegExpsEqual(a, b) {
-  return a.source === b.source && a.flags === b.flags;
-}
-function areSetsEqual(a, b, state) {
-  var size = a.size;
-  if (size !== b.size) {
-    return false;
-  }
-  if (!size) {
-    return true;
-  }
-  var matchedIndices = new Array(size);
-  var aIterable = a.values();
-  var aResult;
-  var bResult;
-  while (aResult = aIterable.next()) {
-    if (aResult.done) {
-      break;
+    const split = filter.split(".");
+    if ([split[0], split[1]].includes("or")) {
+      let foreignTable;
+      if (split[1] === "or") {
+        foreignTable = split[0];
+      }
+      const orFilters = filter.slice(4 + (foreignTable ? foreignTable.length + 1 : 0), -1).split(",").reduce((prev, curr, idx, filters) => {
+        if (curr.startsWith("and(")) {
+          prev = [...prev, [curr, filters[idx + 1]].join()];
+        } else if (!curr.endsWith(")")) {
+          prev = [...prev, curr];
+        }
+        return prev;
+      }, []).map((s) => this.parseFilterString(s, foreignTable)).filter(isNotNull);
+      if (orFilters.length === 0) return null;
+      else return {
+        or: orFilters
+      };
     }
-    var bIterable = b.values();
-    var hasMatch = false;
-    var matchIndex = 0;
-    while (bResult = bIterable.next()) {
-      if (bResult.done) {
+    const operatorIdx = findLastIndex(split, (s) => SUPPORTED_OPERATORS.includes(s));
+    if (operatorIdx === -1) throw new Error(`Could not find a valid operator in ${split.join(".")}. Supported are ${SUPPORTED_OPERATORS.join(",")}.`);
+    const negate = split[operatorIdx - 1] === "not";
+    const pathOrAlias = [prefix, ...split.slice(0, negate ? operatorIdx - 1 : operatorIdx)].filter(Boolean).join(".").replace(/\s/g, "");
+    let path = pathOrAlias;
+    let alias;
+    for (const p of this.paths) {
+      if (p.path === pathOrAlias) {
+        alias = p.alias;
         break;
       }
-      if (!matchedIndices[matchIndex] && state.equals(aResult.value, bResult.value, aResult.value, bResult.value, a, b, state)) {
-        hasMatch = matchedIndices[matchIndex] = true;
+      if (p.alias === pathOrAlias) {
+        path = p.path;
+        alias = p.alias;
         break;
       }
-      matchIndex++;
     }
-    if (!hasMatch) {
-      return false;
+    if (this.opts && Array.isArray(this.opts.exclusivePaths) && !this.opts.exclusivePaths.includes(path)) {
+      return null;
     }
+    const operator = split[operatorIdx];
+    const value = split.slice(operatorIdx + 1).join(".");
+    return {
+      path,
+      alias,
+      negate,
+      operator,
+      value: parseValue(value)
+    };
   }
-  return true;
-}
-function areTypedArraysEqual(a, b) {
-  var index = a.length;
-  if (b.length !== index) {
-    return false;
-  }
-  while (index-- > 0) {
-    if (a[index] !== b[index]) {
-      return false;
-    }
-  }
-  return true;
-}
-function areUrlsEqual(a, b) {
-  return a.hostname === b.hostname && a.pathname === b.pathname && a.protocol === b.protocol && a.port === b.port && a.hash === b.hash && a.username === b.username && a.password === b.password;
-}
-function isPropertyEqual(a, b, state, property) {
-  if ((property === REACT_OWNER || property === PREACT_OWNER || property === PREACT_VNODE) && (a.$$typeof || b.$$typeof)) {
-    return true;
-  }
-  return hasOwn(b, property) && state.equals(a[property], b[property], property, property, a, b, state);
-}
-var ARGUMENTS_TAG = "[object Arguments]";
-var BOOLEAN_TAG = "[object Boolean]";
-var DATE_TAG = "[object Date]";
-var ERROR_TAG = "[object Error]";
-var MAP_TAG = "[object Map]";
-var NUMBER_TAG = "[object Number]";
-var OBJECT_TAG = "[object Object]";
-var REG_EXP_TAG = "[object RegExp]";
-var SET_TAG = "[object Set]";
-var STRING_TAG = "[object String]";
-var URL_TAG = "[object URL]";
-var isArray = Array.isArray;
-var isTypedArray = typeof ArrayBuffer === "function" && ArrayBuffer.isView ? ArrayBuffer.isView : null;
-var assign = Object.assign;
-var getTag = Object.prototype.toString.call.bind(Object.prototype.toString);
-function createEqualityComparator(_a) {
-  var areArraysEqual2 = _a.areArraysEqual, areDatesEqual2 = _a.areDatesEqual, areErrorsEqual2 = _a.areErrorsEqual, areFunctionsEqual2 = _a.areFunctionsEqual, areMapsEqual2 = _a.areMapsEqual, areNumbersEqual2 = _a.areNumbersEqual, areObjectsEqual2 = _a.areObjectsEqual, arePrimitiveWrappersEqual2 = _a.arePrimitiveWrappersEqual, areRegExpsEqual2 = _a.areRegExpsEqual, areSetsEqual2 = _a.areSetsEqual, areTypedArraysEqual2 = _a.areTypedArraysEqual, areUrlsEqual2 = _a.areUrlsEqual;
-  return function comparator(a, b, state) {
-    if (a === b) {
-      return true;
-    }
-    if (a == null || b == null) {
-      return false;
-    }
-    var type = typeof a;
-    if (type !== typeof b) {
-      return false;
-    }
-    if (type !== "object") {
-      if (type === "number") {
-        return areNumbersEqual2(a, b, state);
-      }
-      if (type === "function") {
-        return areFunctionsEqual2(a, b, state);
+};
+
+// src/parser/PostgrestParser.ts
+var PostgrestParser = class extends PostgrestQueryParser {
+  constructor(fb, opts) {
+    super(new URL(fb["url"]).searchParams.toString(), opts);
+    this.opts = opts;
+    this._url = new URL(fb["url"]);
+    const headers = fb["headers"];
+    this._headers = Object.fromEntries(headers.entries());
+    this._body = isObject(fb["body"]) ? {
+      ...fb["body"]
+    } : void 0;
+    this.method = fb["method"];
+    this.searchParams = this._url.searchParams;
+    this.queryKey = sortSearchParams(this._url.searchParams).toString();
+    this.select = this._url.searchParams.get("select")?.toString() ?? "*";
+    this.table = this._url.toString().split("/rest/v1/").pop().split("?").shift();
+    if (this._body) {
+      this.bodyKey = encodeObject(this._body);
+    }
+    const preferHeaders = (this._headers["Prefer"] ?? "").split(",").reduce((prev, curr) => {
+      const s = curr.split("=");
+      return {
+        ...prev,
+        [s[0]]: s[1]
+      };
+    }, {});
+    this.count = preferHeaders["count"] ?? null;
+    this.schema = fb["schema"];
+    this.isHead = this.method === "HEAD";
+    const limit = this._url.searchParams.get("limit");
+    this.limit = limit ? Number(limit) : void 0;
+    const offset = this._url.searchParams.get("offset");
+    this.offset = offset ? Number(offset) : void 0;
+    this._url.searchParams.forEach((value, key) => {
+      const split = key.split(".");
+      if (split[split.length === 2 ? 1 : 0] === "order") {
+        const orderByDefs = value.split(",");
+        orderByDefs.forEach((def) => {
+          const [column, ascending, nullsFirst] = def.split(".");
+          this.orderBy.push({
+            ascending: ascending === "asc",
+            column,
+            nullsFirst: nullsFirst === "nullsfirst",
+            foreignTable: split.length === 2 ? split[0] : void 0
+          });
+        });
       }
-      return false;
-    }
-    var constructor = a.constructor;
-    if (constructor !== b.constructor) {
-      return false;
-    }
-    if (constructor === Object) {
-      return areObjectsEqual2(a, b, state);
-    }
-    if (isArray(a)) {
-      return areArraysEqual2(a, b, state);
-    }
-    if (isTypedArray != null && isTypedArray(a)) {
-      return areTypedArraysEqual2(a, b, state);
-    }
-    if (constructor === Date) {
-      return areDatesEqual2(a, b, state);
-    }
-    if (constructor === RegExp) {
-      return areRegExpsEqual2(a, b, state);
-    }
-    if (constructor === Map) {
-      return areMapsEqual2(a, b, state);
-    }
-    if (constructor === Set) {
-      return areSetsEqual2(a, b, state);
-    }
-    var tag = getTag(a);
-    if (tag === DATE_TAG) {
-      return areDatesEqual2(a, b, state);
-    }
-    if (tag === REG_EXP_TAG) {
-      return areRegExpsEqual2(a, b, state);
-    }
-    if (tag === MAP_TAG) {
-      return areMapsEqual2(a, b, state);
-    }
-    if (tag === SET_TAG) {
-      return areSetsEqual2(a, b, state);
-    }
-    if (tag === OBJECT_TAG) {
-      return typeof a.then !== "function" && typeof b.then !== "function" && areObjectsEqual2(a, b, state);
-    }
-    if (tag === URL_TAG) {
-      return areUrlsEqual2(a, b, state);
-    }
-    if (tag === ERROR_TAG) {
-      return areErrorsEqual2(a, b, state);
-    }
-    if (tag === ARGUMENTS_TAG) {
-      return areObjectsEqual2(a, b, state);
-    }
-    if (tag === BOOLEAN_TAG || tag === NUMBER_TAG || tag === STRING_TAG) {
-      return arePrimitiveWrappersEqual2(a, b, state);
-    }
-    return false;
-  };
-}
-function createEqualityComparatorConfig(_a) {
-  var circular = _a.circular, createCustomConfig = _a.createCustomConfig, strict = _a.strict;
-  var config = {
-    areArraysEqual: strict ? areObjectsEqualStrict : areArraysEqual,
-    areDatesEqual,
-    areErrorsEqual,
-    areFunctionsEqual,
-    areMapsEqual: strict ? combineComparators(areMapsEqual, areObjectsEqualStrict) : areMapsEqual,
-    areNumbersEqual,
-    areObjectsEqual: strict ? areObjectsEqualStrict : areObjectsEqual,
-    arePrimitiveWrappersEqual,
-    areRegExpsEqual,
-    areSetsEqual: strict ? combineComparators(areSetsEqual, areObjectsEqualStrict) : areSetsEqual,
-    areTypedArraysEqual: strict ? areObjectsEqualStrict : areTypedArraysEqual,
-    areUrlsEqual
-  };
-  if (createCustomConfig) {
-    config = assign({}, config, createCustomConfig(config));
-  }
-  if (circular) {
-    var areArraysEqual$1 = createIsCircular(config.areArraysEqual);
-    var areMapsEqual$1 = createIsCircular(config.areMapsEqual);
-    var areObjectsEqual$1 = createIsCircular(config.areObjectsEqual);
-    var areSetsEqual$1 = createIsCircular(config.areSetsEqual);
-    config = assign({}, config, {
-      areArraysEqual: areArraysEqual$1,
-      areMapsEqual: areMapsEqual$1,
-      areObjectsEqual: areObjectsEqual$1,
-      areSetsEqual: areSetsEqual$1
     });
-  }
-  return config;
-}
-function createInternalEqualityComparator(compare) {
-  return function(a, b, _indexOrKeyA, _indexOrKeyB, _parentA, _parentB, state) {
-    return compare(a, b, state);
-  };
-}
-function createIsEqual(_a) {
-  var circular = _a.circular, comparator = _a.comparator, createState = _a.createState, equals = _a.equals, strict = _a.strict;
-  if (createState) {
-    return function isEqual(a, b) {
-      var _a2 = createState(), _b = _a2.cache, cache = _b === void 0 ? circular ? /* @__PURE__ */ new WeakMap() : void 0 : _b, meta = _a2.meta;
-      return comparator(a, b, {
-        cache,
-        equals,
-        meta,
-        strict
-      });
-    };
-  }
-  if (circular) {
-    return function isEqual(a, b) {
-      return comparator(a, b, {
-        cache: /* @__PURE__ */ new WeakMap(),
-        equals,
-        meta: void 0,
-        strict
-      });
-    };
-  }
-  var state = {
-    cache: void 0,
-    equals,
-    meta: void 0,
-    strict
-  };
-  return function isEqual(a, b) {
-    return comparator(a, b, state);
-  };
-}
-var deepEqual = createCustomEqual();
-var strictDeepEqual = createCustomEqual({ strict: true });
-var circularDeepEqual = createCustomEqual({ circular: true });
-var strictCircularDeepEqual = createCustomEqual({
-  circular: true,
-  strict: true
-});
-var shallowEqual = createCustomEqual({
-  createInternalComparator: function() {
-    return sameValueZeroEqual;
-  }
-});
-var strictShallowEqual = createCustomEqual({
-  strict: true,
-  createInternalComparator: function() {
-    return sameValueZeroEqual;
-  }
-});
-var circularShallowEqual = createCustomEqual({
-  circular: true,
-  createInternalComparator: function() {
-    return sameValueZeroEqual;
-  }
-});
-var strictCircularShallowEqual = createCustomEqual({
-  circular: true,
-  createInternalComparator: function() {
-    return sameValueZeroEqual;
-  },
-  strict: true
-});
-function createCustomEqual(options) {
-  if (options === void 0) {
-    options = {};
-  }
-  var _a = options.circular, circular = _a === void 0 ? false : _a, createCustomInternalComparator = options.createInternalComparator, createState = options.createState, _b = options.strict, strict = _b === void 0 ? false : _b;
-  var config = createEqualityComparatorConfig(options);
-  var comparator = createEqualityComparator(config);
-  var equals = createCustomInternalComparator ? createCustomInternalComparator(comparator) : createInternalEqualityComparator(comparator);
-  return createIsEqual({ circular, comparator, createState, equals, strict });
-}
+    this.orderByKey = this.orderBy.map(({
+      column,
+      ascending,
+      nullsFirst,
+      foreignTable
+    }) => `${foreignTable ? `${foreignTable}.` : ""}${column}:${ascending ? "asc" : "desc"}.${nullsFirst ? "nullsFirst" : "nullsLast"}`).join("|");
+  }
+  _url;
+  _headers;
+  _body;
+  method;
+  select;
+  queryKey;
+  bodyKey;
+  count;
+  schema;
+  table;
+  isHead;
+  limit;
+  offset;
+  orderBy = [];
+  orderByKey;
+  searchParams;
+};
 
 export {
-  src_default,
-  flatten,
-  unflatten,
-  deepEqual
+  sortSearchParams,
+  encodeObject,
+  isObject,
+  findLastIndex,
+  isNotNull,
+  OPERATOR_MAP,
+  parseSelectParam,
+  isISODateString,
+  parseValue,
+  SUPPORTED_OPERATORS,
+  PostgrestQueryParser,
+  PostgrestParser
 };
 /*! Bundled license information:
 
 xregexp/src/xregexp.js:
   (*!
-   * XRegExp 5.1.1
+   * XRegExp 5.1.2
    * <xregexp.com>
    * Steven Levithan (c) 2007-present MIT License
    *)
 
 xregexp/src/addons/build.js:
   (*!
-   * XRegExp.build 5.1.1
+   * XRegExp.build 5.1.2
    * <xregexp.com>
    * Steven Levithan (c) 2012-present MIT License
    *)
 
 xregexp/src/addons/matchrecursive.js:
   (*!
-   * XRegExp.matchRecursive 5.1.1
+   * XRegExp.matchRecursive 5.1.2
    * <xregexp.com>
    * Steven Levithan (c) 2009-present MIT License
    *)
 
 xregexp/src/addons/unicode-base.js:
   (*!
-   * XRegExp Unicode Base 5.1.1
+   * XRegExp Unicode Base 5.1.2
    * <xregexp.com>
    * Steven Levithan (c) 2008-present MIT License
    *)
 
 xregexp/src/addons/unicode-categories.js:
   (*!
-   * XRegExp Unicode Categories 5.1.1
+   * XRegExp Unicode Categories 5.1.2
    * <xregexp.com>
    * Steven Levithan (c) 2010-present MIT License
    * Unicode data by Mathias Bynens <mathiasbynens.be>
@@ -2761,7 +2652,7 @@ xregexp/src/addons/unicode-categories.js:
 
 xregexp/src/addons/unicode-properties.js:
   (*!
-   * XRegExp Unicode Properties 5.1.1
+   * XRegExp Unicode Properties 5.1.2
    * <xregexp.com>
    * Steven Levithan (c) 2012-present MIT License
    * Unicode data by Mathias Bynens <mathiasbynens.be>
@@ -2769,10 +2660,10 @@ xregexp/src/addons/unicode-properties.js:
 
 xregexp/src/addons/unicode-scripts.js:
   (*!
-   * XRegExp Unicode Scripts 5.1.1
+   * XRegExp Unicode Scripts 5.1.2
    * <xregexp.com>
    * Steven Levithan (c) 2010-present MIT License
    * Unicode data by Mathias Bynens <mathiasbynens.be>
    *)
 */
-//# sourceMappingURL=chunk-AKIRHA4Q.js.map
+//# sourceMappingURL=chunk-UJWETW36.js.map