@pol-studios/db 1.0.53 → 1.0.55

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

@@ -1,15 +1,11 @@
-import {
-  deepEqual,
-  flatten
-} from "./chunk-INEUG6MC.js";
 import {
   __commonJS,
   __toESM
 } from "./chunk-7D4SUZUM.js";
 
-// ../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/tools/output/categories.js
+// ../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/tools/output/categories.js
 var require_categories = __commonJS({
-  "../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/tools/output/categories.js"(exports, module) {
+  "../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/tools/output/categories.js"(exports, module) {
     module.exports = [
       {
         "name": "C",
@@ -231,9 +227,9 @@ var require_categories = __commonJS({
   }
 });
 
-// ../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/tools/output/properties.js
+// ../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/tools/output/properties.js
 var require_properties = __commonJS({
-  "../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/tools/output/properties.js"(exports, module) {
+  "../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/tools/output/properties.js"(exports, module) {
     module.exports = [
       {
         "name": "ASCII",
@@ -278,9 +274,9 @@ var require_properties = __commonJS({
   }
 });
 
-// ../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/tools/output/scripts.js
+// ../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/tools/output/scripts.js
 var require_scripts = __commonJS({
-  "../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/tools/output/scripts.js"(exports, module) {
+  "../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/tools/output/scripts.js"(exports, module) {
     module.exports = [
       {
         "name": "Adlam",
@@ -946,90 +942,15 @@ var require_scripts = __commonJS({
   }
 });
 
-// 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
+// ../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/src/xregexp.js
 var REGEX_DATA = "xregexp";
 var features = {
   astral: false,
   namespacing: true
 };
 var fixed = {};
-var regexCache = /* @__PURE__ */ Object.create(null);
-var patternCache = /* @__PURE__ */ Object.create(null);
+var regexCache = {};
+var patternCache = {};
 var tokens = [];
 var defaultScope = "default";
 var classScope = "class";
@@ -1335,7 +1256,7 @@ function XRegExp(pattern, flags) {
   );
 }
 XRegExp.prototype = new RegExp();
-XRegExp.version = "5.1.2";
+XRegExp.version = "5.1.1";
 XRegExp._clipDuplicates = clipDuplicates;
 XRegExp._hasNativeFlag = hasNativeFlag;
 XRegExp._dec = dec;
@@ -1375,9 +1296,9 @@ XRegExp.cache = (pattern, flags) => {
 };
 XRegExp.cache.flush = (cacheName) => {
   if (cacheName === "patterns") {
-    patternCache = /* @__PURE__ */ Object.create(null);
+    patternCache = {};
   } else {
-    regexCache = /* @__PURE__ */ Object.create(null);
+    regexCache = {};
   }
 };
 XRegExp.escape = (str) => String(nullThrows(str)).replace(/[\\\[\]{}()*+?.^$|]/g, "\\$&").replace(/[\s#\-,]/g, (match) => `\\u${pad4(hex(match.charCodeAt(0)))}`);
@@ -1830,7 +1751,7 @@ XRegExp.addToken(
 );
 var xregexp_default = XRegExp;
 
-// ../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/src/addons/build.js
+// ../../../node_modules/.pnpm/xregexp@5.1.1/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;
@@ -1954,7 +1875,7 @@ var build_default = (XRegExp2) => {
   };
 };
 
-// ../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/src/addons/matchrecursive.js
+// ../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/src/addons/matchrecursive.js
 var matchrecursive_default = (XRegExp2) => {
   function row(name, value, start, end) {
     return {
@@ -2084,7 +2005,7 @@ var matchrecursive_default = (XRegExp2) => {
   };
 };
 
-// ../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/src/addons/unicode-base.js
+// ../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/src/addons/unicode-base.js
 var unicode_base_default = (XRegExp2) => {
   const unicode = {};
   const unicodeTypes = {};
@@ -2236,7 +2157,7 @@ var unicode_base_default = (XRegExp2) => {
   };
 };
 
-// ../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/src/addons/unicode-categories.js
+// ../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/src/addons/unicode-categories.js
 var import_categories = __toESM(require_categories());
 var unicode_categories_default = (XRegExp2) => {
   if (!XRegExp2.addUnicodeData) {
@@ -2245,7 +2166,7 @@ var unicode_categories_default = (XRegExp2) => {
   XRegExp2.addUnicodeData(import_categories.default);
 };
 
-// ../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/src/addons/unicode-properties.js
+// ../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/src/addons/unicode-properties.js
 var import_properties = __toESM(require_properties());
 var unicode_properties_default = (XRegExp2) => {
   if (!XRegExp2.addUnicodeData) {
@@ -2261,7 +2182,7 @@ var unicode_properties_default = (XRegExp2) => {
   XRegExp2.addUnicodeData(unicodeData);
 };
 
-// ../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/src/addons/unicode-scripts.js
+// ../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/src/addons/unicode-scripts.js
 var import_scripts = __toESM(require_scripts());
 var unicode_scripts_default = (XRegExp2) => {
   if (!XRegExp2.addUnicodeData) {
@@ -2270,7 +2191,7 @@ var unicode_scripts_default = (XRegExp2) => {
   XRegExp2.addUnicodeData(import_scripts.default, "Script");
 };
 
-// ../../../node_modules/.pnpm/xregexp@5.1.2/node_modules/xregexp/src/index.js
+// ../../../node_modules/.pnpm/xregexp@5.1.1/node_modules/xregexp/src/index.js
 build_default(xregexp_default);
 matchrecursive_default(xregexp_default);
 unicode_base_default(xregexp_default);
@@ -2279,372 +2200,560 @@ unicode_properties_default(xregexp_default);
 unicode_scripts_default(xregexp_default);
 var src_default = xregexp_default;
 
-// 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
-      };
+// ../../../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)
+      );
     }
-    return prev;
   }, {});
-  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(".")
-    };
+  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);
   });
-  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
-    });
-  })];
-};
-
-// 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 result;
+}
 
-// 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;
+// ../../../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 this._filters;
   }
-  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 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;
     }
-    const split = filter.split(".");
-    if ([split[0], split[1]].includes("or")) {
-      let foreignTable;
-      if (split[1] === "or") {
-        foreignTable = split[0];
+    var bIterable = b.entries();
+    var hasMatch = false;
+    var matchIndex = 0;
+    while (bResult = bIterable.next()) {
+      if (bResult.done) {
+        break;
       }
-      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
-      };
+      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++;
+  }
+  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;
     }
-    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;
+  }
+  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;
+    }
+  }
+  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;
+    }
+    var bIterable = b.values();
+    var hasMatch = false;
+    var matchIndex = 0;
+    while (bResult = bIterable.next()) {
+      if (bResult.done) {
         break;
       }
-      if (p.alias === pathOrAlias) {
-        path = p.path;
-        alias = p.alias;
+      if (!matchedIndices[matchIndex] && state.equals(aResult.value, bResult.value, aResult.value, bResult.value, a, b, state)) {
+        hasMatch = matchedIndices[matchIndex] = true;
         break;
       }
+      matchIndex++;
     }
-    if (this.opts && Array.isArray(this.opts.exclusivePaths) && !this.opts.exclusivePaths.includes(path)) {
-      return null;
+    if (!hasMatch) {
+      return false;
     }
-    const operator = split[operatorIdx];
-    const value = split.slice(operatorIdx + 1).join(".");
-    return {
-      path,
-      alias,
-      negate,
-      operator,
-      value: parseValue(value)
-    };
   }
-};
-
-// 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 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);
       }
+      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
     });
-    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;
-};
+  }
+  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 });
+}
 
 export {
-  sortSearchParams,
-  encodeObject,
-  isObject,
-  findLastIndex,
-  isNotNull,
-  OPERATOR_MAP,
-  parseSelectParam,
-  isISODateString,
-  parseValue,
-  SUPPORTED_OPERATORS,
-  PostgrestQueryParser,
-  PostgrestParser
+  src_default,
+  flatten,
+  unflatten,
+  deepEqual
 };
 /*! Bundled license information:
 
 xregexp/src/xregexp.js:
   (*!
-   * XRegExp 5.1.2
+   * XRegExp 5.1.1
    * <xregexp.com>
    * Steven Levithan (c) 2007-present MIT License
    *)
 
 xregexp/src/addons/build.js:
   (*!
-   * XRegExp.build 5.1.2
+   * XRegExp.build 5.1.1
    * <xregexp.com>
    * Steven Levithan (c) 2012-present MIT License
    *)
 
 xregexp/src/addons/matchrecursive.js:
   (*!
-   * XRegExp.matchRecursive 5.1.2
+   * XRegExp.matchRecursive 5.1.1
    * <xregexp.com>
    * Steven Levithan (c) 2009-present MIT License
    *)
 
 xregexp/src/addons/unicode-base.js:
   (*!
-   * XRegExp Unicode Base 5.1.2
+   * XRegExp Unicode Base 5.1.1
    * <xregexp.com>
    * Steven Levithan (c) 2008-present MIT License
    *)
 
 xregexp/src/addons/unicode-categories.js:
   (*!
-   * XRegExp Unicode Categories 5.1.2
+   * XRegExp Unicode Categories 5.1.1
    * <xregexp.com>
    * Steven Levithan (c) 2010-present MIT License
    * Unicode data by Mathias Bynens <mathiasbynens.be>
@@ -2652,7 +2761,7 @@ xregexp/src/addons/unicode-categories.js:
 
 xregexp/src/addons/unicode-properties.js:
   (*!
-   * XRegExp Unicode Properties 5.1.2
+   * XRegExp Unicode Properties 5.1.1
    * <xregexp.com>
    * Steven Levithan (c) 2012-present MIT License
    * Unicode data by Mathias Bynens <mathiasbynens.be>
@@ -2660,10 +2769,10 @@ xregexp/src/addons/unicode-properties.js:
 
 xregexp/src/addons/unicode-scripts.js:
   (*!
-   * XRegExp Unicode Scripts 5.1.2
+   * XRegExp Unicode Scripts 5.1.1
    * <xregexp.com>
    * Steven Levithan (c) 2010-present MIT License
    * Unicode data by Mathias Bynens <mathiasbynens.be>
    *)
 */
-//# sourceMappingURL=chunk-UJWETW36.js.map
+//# sourceMappingURL=chunk-AKIRHA4Q.js.map