{"version":3,"sources":["../src/index.ts","../src/lib/query-types.ts","../src/lib/extract-paths-from-filter.ts","../src/lib/remove-first-path-element.ts","../src/lib/group-paths-recursive.ts","../src/lib/parse-select-param.ts","../src/lib/remove-alias-from-declaration.ts","../src/fetch/build-select-statement.ts","../src/fetch/dedupe.ts","../src/fetch/build-normalized-query.ts","../src/lib/get.ts","../src/lib/is-plain-object.ts","../src/fetch/build-mutation-fetcher-response.ts","../src/lib/get-table-from-url.ts","../src/lib/like-query-builder.ts","../src/lib/get-table.ts","../src/lib/cache-data-types.ts","../src/lib/response-types.ts","../src/lib/sort-search-param.ts","../src/lib/encode-object.ts","../src/lib/is-postgrest-builder.ts","../src/lib/is-postgrest-transform-builder.ts","../src/lib/set-filter-value.ts","../src/lib/is-iso-date-string.ts","../src/lib/parse-value.ts","../src/lib/parse-order-by-key.ts","../src/lib/parse-order-by.ts","../src/lib/find-filters.ts","../src/cursor-pagination-fetcher.ts","../src/delete-fetcher.ts","../src/mutate/should-revalidate-relation.ts","../src/mutate/should-revalidate-table.ts","../src/mutate/transformers.ts","../src/delete-item.ts","../src/fetcher.ts","../src/insert-fetcher.ts","../src/lib/binary-search.ts","../src/lib/if-date-get-time.ts","../src/lib/sorted-comparator.ts","../src/lib/find-index-ordered.ts","../src/mutate-item.ts","../src/offset-pagination-fetcher.ts","../src/filter/denormalize.ts","../src/lib/filter-filter-definitions-by-paths.ts","../src/lib/is-object.ts","../src/lib/like-postgrest-builder.ts","../src/lib/operators.ts","../src/lib/find-last-index.ts","../src/lib/is-not-null.ts","../src/postgrest-query-parser.ts","../src/postgrest-filter.ts","../src/postgrest-parser.ts","../src/update-fetcher.ts","../src/upsert-fetcher.ts","../src/upsert-item.ts","../src/revalidate-tables.ts"],"sourcesContent":["// cherry pick exports that are used by the adapter packages\nexport * from './lib/postgrest-types';\nexport * from './fetch/build-normalized-query';\nexport * from './fetch/build-mutation-fetcher-response';\nexport * from './mutate/types';\nexport * from './lib/query-types';\nexport * from './lib/get-table';\nexport * from './lib/cache-data-types';\nexport * from './lib/response-types';\nexport * from './lib/encode-object';\nexport * from './lib/is-postgrest-builder';\nexport * from './lib/is-postgrest-transform-builder';\nexport * from './lib/get';\nexport * from './lib/set-filter-value';\nexport * from './lib/parse-value';\nexport * from './lib/parse-order-by-key';\nexport * from './lib/parse-order-by';\nexport * from './lib/find-filters';\nexport * from './lib/is-plain-object';\n\nexport * from './cursor-pagination-fetcher';\nexport * from './delete-fetcher';\nexport * from './delete-item';\nexport * from './fetcher';\nexport * from './insert-fetcher';\nexport * from './mutate-item';\nexport * from './offset-pagination-fetcher';\nexport * from './postgrest-filter';\nexport * from './postgrest-parser';\nexport * from './postgrest-query-parser';\nexport * from './update-fetcher';\nexport * from './upsert-fetcher';\nexport * from './upsert-item';\nexport * from './revalidate-tables';\n","/**\n * A function that validates whether the given input is an object of type Type\n * @returns true if obj is of type Type, false if not\n */\nexport type FilterFn<Type extends Record<string, unknown>> = (\n  obj: unknown,\n) => obj is Type;\n\n/**\n * The supported value types\n */\nexport type ValueType = number | string | boolean | null | Date | object;\n\n/**\n * A function implementing a FilterOperators\n * @param columnValue the value of the input object to test the filter against\n * @param filterValue the value of the filter, e.g. in .eq('colname', 'filterValue'), 'filterValue' would be the filterValue\n * @returns true if the filter applies, false if not\n */\nexport type OperatorFn = (columnValue: any, filterValue: any) => boolean;\n\n/**\n * All supported operators of PostgREST\n */\nexport type FilterOperator =\n  | 'or'\n  | 'eq'\n  | 'neq'\n  | 'gt'\n  | 'gte'\n  | 'lt'\n  | 'lte'\n  | 'like'\n  | 'ilike'\n  | 'is'\n  | 'in'\n  | 'cs'\n  | 'cd'\n  | 'ov'\n  | 'fts'\n  | 'plfts';\n\n/**\n * An object describing a selected path of a query\n *\n */\nexport type Path = {\n  /**\n   * The aliased path if a column or relation name mapping is used within the path\n   */\n  alias?: string;\n  /**\n   * The \"real\" path of a column\n   */\n  path: string;\n  /**\n   * The full declaration of a column that includes alias, hints and inner joins\n   */\n  declaration: string;\n  /**\n   * The aggregate function applied to the path\n   */\n  aggregate?: string;\n};\n\n/**\n * A decomposed filter applied to a query\n */\nexport type FilterDefinition = {\n  /**\n   * The path to which the filter is applied\n   */\n  path: string;\n  /**\n   * The aliased path if a column or relation name mapping is used\n   */\n  alias?: string;\n  /**\n   * The operator that is applied\n   */\n  operator: FilterOperator;\n  /**\n   * Whether or not to negate the results of the filter, e.g. when .not('name', 'eq', 'Paris') is applied\n   */\n  negate: boolean;\n  /**\n   * The value of the filter\n   */\n  value: ValueType;\n};\n\n/**\n * A json representation of PostgREST filters that are applied to a query\n */\nexport type FilterDefinitions = (\n  | { or: FilterDefinitions }\n  | { and: FilterDefinitions }\n  | FilterDefinition\n)[];\n\ntype ArrayElement<ArrayType extends readonly unknown[]> =\n  ArrayType extends readonly (infer ElementType)[] ? ElementType : never;\n\nexport const isAndFilter = (\n  f: ArrayElement<FilterDefinitions>,\n): f is { and: FilterDefinitions } =>\n  Array.isArray((f as { and: FilterDefinitions }).and);\n\nexport const isOrFilter = (\n  f: ArrayElement<FilterDefinitions>,\n): f is { or: FilterDefinitions } =>\n  Array.isArray((f as { or: FilterDefinitions }).or);\n\nexport const isFilterDefinition = (\n  f: ArrayElement<FilterDefinitions>,\n): f is FilterDefinition => !isAndFilter(f) && !isOrFilter(f);\n\nexport type OrderDefinition = {\n  column: string;\n  ascending: boolean;\n  nullsFirst: boolean;\n  foreignTable?: string;\n};\n","import {\n  type FilterDefinitions,\n  type Path,\n  isAndFilter,\n  isFilterDefinition,\n  isOrFilter,\n} from './query-types';\n\nexport const extractPathsFromFilters = (f: FilterDefinitions, p: Path[]) => {\n  return f.reduce<Path[]>((prev, filter) => {\n    if (isAndFilter(filter)) {\n      prev.push(...extractPathsFromFilters(filter.and, p));\n    } else if (isOrFilter(filter)) {\n      prev.push(...extractPathsFromFilters(filter.or, p));\n    } else if (isFilterDefinition(filter)) {\n      const relatedPath = p.find((p) => p.path === filter.path);\n      const pathElements = filter.path.split('.');\n      const aliasElements = filter.alias?.split('.');\n      const declaration = pathElements\n        .map(\n          (el, idx) =>\n            `${aliasElements && aliasElements[idx] !== el ? `${aliasElements[idx]}:` : ''}${el}`,\n        )\n        .join('.');\n      prev.push({\n        path: filter.path,\n        alias: filter.alias,\n        declaration: relatedPath ? relatedPath.declaration : declaration,\n      });\n    }\n    return prev;\n  }, []);\n};\n","import type { Path } from './query-types';\n\nexport const removeFirstPathElement = (p: Path): Path => {\n  const aliasWithoutFirstElement = p.alias\n    ? p.alias.split('.').slice(1).join('.')\n    : undefined;\n  const pathWithoutFirstEelment = p.path.split('.').slice(1).join('.');\n\n  return {\n    declaration: p.declaration.split('.').slice(1).join('.'),\n    path: pathWithoutFirstEelment,\n    alias:\n      aliasWithoutFirstElement &&\n      (aliasWithoutFirstElement.split('.').length > 1 ||\n        aliasWithoutFirstElement !== pathWithoutFirstEelment)\n        ? aliasWithoutFirstElement\n        : undefined,\n  };\n};\n","import type { Path } from './query-types';\nimport { removeFirstPathElement } from './remove-first-path-element';\n\nexport type NestedPath = {\n  alias?: string;\n  path: string;\n  declaration: string;\n  paths: (Path | NestedPath)[];\n};\n\nexport const isNestedPath = (p: Path | NestedPath): p is NestedPath =>\n  Array.isArray((p as NestedPath).paths);\n\n// group paths by first path elements declaration\n// returns [Path, Path, NestedPath, NestedPath, Path]\nexport const groupPathsRecursive = (paths: Path[]): (Path | NestedPath)[] => {\n  const grouped = paths.reduce<(Path | NestedPath)[]>((prev, curr) => {\n    const levels = curr.path.split('.').length;\n    if (levels === 1) {\n      prev.push(curr);\n      return prev;\n    }\n\n    // if has more than one level left,\n    const firstLevelDeclaration = curr.declaration.split('.')[0];\n    const indexOfNested = prev.findIndex(\n      (p) => isNestedPath(p) && p.declaration === firstLevelDeclaration,\n    );\n    const pathWithoutCurrentLevel = removeFirstPathElement(curr);\n    if (indexOfNested !== -1) {\n      // add to nested\n      (prev[indexOfNested] as NestedPath).paths.push(pathWithoutCurrentLevel);\n      return prev;\n    }\n    // create nested\n    prev.push({\n      declaration: firstLevelDeclaration,\n      path: curr.path.split('.')[0],\n      paths: [pathWithoutCurrentLevel],\n      ...(curr.alias ? { alias: curr.alias.split('.')[0] } : {}),\n    });\n    return prev;\n  }, []);\n\n  return grouped.map((p) =>\n    isNestedPath(p) ? { ...p, paths: groupPathsRecursive(p.paths) } : p,\n  );\n};\n","import type { Path } from './query-types';\nimport XRegExp from 'xregexp';\n\nexport const parseSelectParam = (s: string, currentPath?: Path): Path[] => {\n  s = s.replace(/\\s/g, '');\n\n  let result;\n  try {\n    result = XRegExp.matchRecursive(`,${s}`, '([^,\\\\(]+)\\\\(', '\\\\)', 'g', {\n      valueNames: {\n        '0': null,\n        '1': 'tableName',\n        '2': 'selectedColumns',\n        '3': null,\n      },\n    }).map((item) => {\n      if (\n        item.name === 'tableName' &&\n        item.value &&\n        !item.value.startsWith(',')\n      ) {\n        item.value = ',' + item.value;\n      }\n      return item;\n    });\n  } catch (e) {\n    const path = currentPath?.path\n      ? `${currentPath?.declaration} with alias ${currentPath?.alias} at path ${currentPath?.path}`\n      : 'root';\n    throw new Error(`Unable to parse ${s} at ${path}`, {\n      cause: e,\n    });\n  }\n\n  const foreignTables = result.reduce((prev, curr, idx, matches) => {\n    if (curr.name === 'selectedColumns' && curr.value.length > 0) {\n      const name = matches[idx - 1].value.slice(1, -1);\n      prev = { ...prev, [name]: curr.value };\n    }\n    return prev;\n  }, {});\n\n  const columns = s\n    .replace(\n      new RegExp(\n        `${Object.entries(foreignTables)\n          .map(([table, selectedColumns]) =>\n            `${table}(${selectedColumns})`\n              .replace(/\\(/g, '\\\\(')\n              .replace(/\\)/g, '\\\\)')\n              .replace(/\\*/g, '\\\\*'),\n          )\n          .join('|')}`,\n        'g',\n      ),\n      '',\n    )\n    .replace(/(,)\\1+/g, ',')\n    .split(',')\n    .filter((c) => c.length > 0)\n    .map((c) => {\n      const split = c.split(':');\n      const hasAlias = split.length > 1;\n\n      const aggregateSplit = split[hasAlias ? 1 : 0].split('.');\n      const hasAggregate =\n        aggregateSplit.length > 1 && aggregateSplit[1].endsWith('()');\n\n      return {\n        declaration: [currentPath?.declaration, c].filter(Boolean).join('.'),\n        alias:\n          hasAlias || currentPath?.alias\n            ? [currentPath?.alias ?? currentPath?.path, split[0]]\n                .filter(Boolean)\n                .join('.')\n            : undefined,\n        path: [\n          currentPath?.path,\n          hasAggregate ? aggregateSplit[0] : split[hasAlias ? 1 : 0],\n        ]\n          .filter(Boolean)\n          .join('.'),\n        ...(hasAggregate ? { aggregate: aggregateSplit[1].slice(0, -2) } : {}),\n      };\n    });\n\n  return [\n    ...columns,\n    ...Object.entries(foreignTables).flatMap(\n      ([currentDeclaration, selectedColumns]) => {\n        // example for declaration\n        // alias:organisation!contact_organisation_id_fkey!inner\n        const aliasSplit = currentDeclaration.split(':');\n\n        const currentAliasElem =\n          aliasSplit.length > 1 ? aliasSplit[0] : undefined;\n\n        const currentPathDeclaration = aliasSplit[aliasSplit.length - 1];\n        const currentPathElem = currentPathDeclaration.split('!')[0];\n\n        const path = [currentPath?.path, currentPathElem]\n          .filter(Boolean)\n          .join('.');\n\n        const alias = [\n          currentPath?.alias ?? currentPath?.path,\n          currentAliasElem ?? currentPathElem,\n        ]\n          .filter(Boolean)\n          .join('.');\n\n        const declaration = [currentPath?.declaration, currentDeclaration]\n          .filter(Boolean)\n          .join('.');\n\n        return parseSelectParam(`${selectedColumns}`, {\n          path,\n          alias: currentPath?.alias || currentAliasElem ? alias : undefined,\n          declaration,\n        });\n      },\n    ),\n  ];\n};\n","// removes alias from every level of declaration\nexport const removeAliasFromDeclaration = (d: string) =>\n  d\n    .split('.')\n    .map((el) => el.split(':').pop() as string)\n    .join('.');\n","import {\n  type NestedPath,\n  groupPathsRecursive,\n  isNestedPath,\n} from '../lib/group-paths-recursive';\nimport type { Path } from '../lib/query-types';\n\n// Transforms a list of Path[] into a select statement\nexport const buildSelectStatement = (paths: Path[]): string => {\n  return buildSelectStatementFromGroupedPaths(groupPathsRecursive(paths));\n};\n\n// Transforms a list of (Path | NestedPath)[] grouped statements into a select statement\nexport const buildSelectStatementFromGroupedPaths = (\n  paths: (Path | NestedPath)[],\n): string =>\n  paths\n    .map((i) => {\n      if (isNestedPath(i)) {\n        return `${i.declaration}(${buildSelectStatement(i.paths)})`;\n      }\n      return `${i.alias ? `${i.alias}:` : ''}${i.path}`;\n    })\n    .join(',');\n","import { type NestedPath, isNestedPath } from '../lib/group-paths-recursive';\nimport type { Path } from '../lib/query-types';\n\nexport const DEDUPE_ALIAS_PREFIX = 'd';\n\nexport const dedupeGroupedPathsRecursive = (\n  grouped: (Path | NestedPath)[],\n): (Path | NestedPath)[] => {\n  const dedupeCounters = new Map<string, number>();\n\n  return grouped.map((p, idx, a) => {\n    // never dedupe non-nested paths because even if there is a duplicate we always want to dedupe the nested path instead\n    // e.g. inbox_id,inbox_id(name) should be deduped to inbox_id,d_0_inbox_id:inbox_id(name)\n    if (!isNestedPath(p)) return p;\n\n    // dedupe current nested path if there is another path with the same `path`\n    if (a.some((i, itemIdx) => i.path === p.path && idx !== itemIdx)) {\n      const counter = dedupeCounters.get(p.path) || 0;\n      dedupeCounters.set(p.path, counter + 1);\n      const alias = [DEDUPE_ALIAS_PREFIX, counter, p.path].join('_');\n      return {\n        ...p,\n        alias,\n        declaration: `${alias}:${p.declaration}`,\n        paths: dedupeGroupedPathsRecursive(p.paths),\n      };\n    }\n\n    return {\n      ...p,\n      paths: dedupeGroupedPathsRecursive(p.paths),\n    };\n  });\n};\n","import { extractPathsFromFilters } from '../lib/extract-paths-from-filter';\nimport {\n  type NestedPath,\n  groupPathsRecursive,\n} from '../lib/group-paths-recursive';\nimport { parseSelectParam } from '../lib/parse-select-param';\nimport type { FilterDefinitions, Path } from '../lib/query-types';\nimport { removeAliasFromDeclaration } from '../lib/remove-alias-from-declaration';\nimport { buildSelectStatementFromGroupedPaths } from './build-select-statement';\nimport { dedupeGroupedPathsRecursive } from './dedupe';\n\nexport type BuildNormalizedQueryOps<Q extends string = '*'> = {\n  query?: Q | null;\n  // if true, will not add any paths from the cache to the query\n  disabled?: boolean;\n  queriesForTable: () => { paths: Path[]; filters: FilterDefinitions }[];\n};\n\nexport type BuildNormalizedQueryReturn = {\n  // The joint select query\n  selectQuery: string;\n  // All paths the user is querying for\n  groupedUserQueryPaths: (NestedPath | Path)[] | null;\n  // All paths the user is querying for + all paths that are currently loaded into the cache\n  groupedPaths: (NestedPath | Path)[];\n};\n\n/**\n * returns select statement that includes the users query + all paths currently loaded into cache to later perform a \"smart update\"\n *\n * the select statement does not contain any user-defined aliases. only custom ones to dedupe.\n * without deduping, we would not be able to query inbox_id,inbox:inbox_id(name),\n * because it will result in a select of inbox_id,inbox_id(name), which does not work.\n * to dedupe, we add a custom alias to the query, e.g. dedupe_0:inbox_id,inbox_id(name)\n * we then later remove them when normalizing the data\n **/\nexport const buildNormalizedQuery = <Q extends string = '*'>({\n  query,\n  disabled,\n  queriesForTable,\n}: BuildNormalizedQueryOps<Q>): BuildNormalizedQueryReturn | null => {\n  // parse user query\n  const userQueryPaths = query ? parseSelectParam(query) : null;\n\n  // unique set of declaration without paths.\n  // alias not needed for paths\n  // declaration without alias!\n  const paths: Path[] = userQueryPaths\n    ? userQueryPaths.map((q) => ({\n        declaration: removeAliasFromDeclaration(q.declaration),\n        path: q.path,\n      }))\n    : [];\n\n  if (!disabled) {\n    for (const tableQuery of queriesForTable()) {\n      for (const filterPath of extractPathsFromFilters(\n        tableQuery.filters,\n        tableQuery.paths,\n      )) {\n        // add paths used in filter\n        const path = tableQuery.paths.find(\n          (p) => p.path === filterPath.path && p.alias === filterPath.alias,\n        ) ?? {\n          path: filterPath.path,\n          declaration: filterPath.path,\n        };\n        // add unique\n        if (\n          paths.every(\n            (p) =>\n              removeAliasFromDeclaration(p.declaration) !==\n              removeAliasFromDeclaration(path.declaration),\n          )\n        ) {\n          // do not use alias\n          paths.push({\n            path: path.path,\n            declaration: removeAliasFromDeclaration(path.declaration),\n          });\n        }\n      }\n      // add paths used in query\n      for (const path of tableQuery.paths) {\n        if (\n          paths.every(\n            (p) =>\n              removeAliasFromDeclaration(p.declaration) !==\n              removeAliasFromDeclaration(path.declaration),\n          ) &&\n          // do not add agg functions\n          !path.declaration.endsWith('.count') &&\n          // do not add wildcard queries\n          !path.declaration.endsWith('*')\n        ) {\n          paths.push({\n            path: path.path,\n            declaration: removeAliasFromDeclaration(path.declaration),\n          });\n        }\n      }\n    }\n  }\n\n  const groupedPaths = groupPathsRecursive(paths);\n  const groupedDedupedPaths = dedupeGroupedPathsRecursive(groupedPaths);\n\n  const selectQuery = buildSelectStatementFromGroupedPaths(groupedDedupedPaths);\n  if (selectQuery.length === 0) return null;\n  return {\n    selectQuery,\n    groupedUserQueryPaths: userQueryPaths\n      ? groupPathsRecursive(userQueryPaths)\n      : null,\n    groupedPaths: groupedDedupedPaths,\n  };\n};\n","export const get = (obj: any, path: string, defaultValue: any = undefined) => {\n  const split = path.split(/((?:\\.|,|\\[|\\]|->>|->)+)/g);\n  let result: any = obj;\n  for (let i = -1; i < split.length; i += 2) {\n    const separator = split[i];\n    let key: string | number = split[i + 1];\n    if (!key) {\n      continue;\n    }\n    if (separator?.endsWith('->') || separator?.endsWith('->>')) {\n      if (/^\\d+$/.test(key)) {\n        key = Number.parseInt(key, 10);\n      }\n    }\n    if (separator?.endsWith('->>')) {\n      result = `${result ? result[key] : result}`;\n    } else {\n      result = result ? result[key] : result;\n    }\n  }\n  return result === undefined || result === obj ? defaultValue : result;\n};\n","export function isPlainObject(\n  value: unknown,\n): value is Record<string, unknown> {\n  return Object.prototype.toString.call(value) === '[object Object]';\n}\n","import { get } from '../lib/get';\nimport { type NestedPath, isNestedPath } from '../lib/group-paths-recursive';\nimport { isPlainObject } from '../lib/is-plain-object';\nimport type { Path } from '../lib/query-types';\nimport type { BuildNormalizedQueryReturn } from './build-normalized-query';\nimport { flatten } from 'flat';\n\n/**\n * The parsed response of the mutation fetcher\n **/\nexport type MutationFetcherResponse<R> = {\n  /**\n   * Normalized response. A flat json object with a depth of 1, where the keys are the full json paths.\n   **/\n  normalizedData: R;\n  /**\n   * Result of the query passed by the user\n   **/\n  userQueryData?: R;\n};\n\nexport const buildMutationFetcherResponse = <R>(\n  /**\n   * response of the select query built by `buildNormalizedQuery`. contains dedupe aliases.\n   **/\n  input: R,\n  {\n    groupedPaths,\n    groupedUserQueryPaths,\n  }: Pick<BuildNormalizedQueryReturn, 'groupedPaths' | 'groupedUserQueryPaths'>,\n): MutationFetcherResponse<R> => {\n  return {\n    normalizedData: normalizeResponse<R>(groupedPaths, input),\n    userQueryData: groupedUserQueryPaths\n      ? buildUserQueryData<R>(groupedUserQueryPaths, groupedPaths, input)\n      : undefined,\n  };\n};\n\n/**\n * Normalize the response by removing the dedupe alias and flattening it\n **/\nexport const normalizeResponse = <R>(\n  groups: (Path | NestedPath)[],\n  obj: R,\n): R => {\n  if (groups.some((p) => p.path === '*')) {\n    // if wildcard, add every non nested value\n    // for every nested value, check if groups contains a nested path for it. if not, also add it.\n    // reason is that the wildcard does not select relations\n\n    Object.entries(obj as Record<string, unknown>).forEach(([k, v]) => {\n      if (typeof v === 'object' || Array.isArray(v)) {\n        if (!groups.some((g) => isNestedPath(g) && g.path === k)) {\n          groups.push({\n            path: k,\n            declaration: k,\n          });\n        }\n      } else if (!groups.some((g) => g.path === k)) {\n        groups.push({\n          path: k,\n          declaration: k,\n        });\n      }\n    });\n  }\n\n  return groups.reduce<R>((prev, curr) => {\n    // prefer alias over path because of dedupe alias\n    const value = get(obj, curr.alias || curr.path);\n\n    if (typeof value === 'undefined') return prev;\n    if (value === null) {\n      return {\n        ...prev,\n        // add hint to path if it has dedupe alias\n        // can happen if the same relation is queried multiple times via different fkeys\n        [`${curr.path}${\n          curr.alias?.startsWith('d_') && curr.declaration.split('!').length > 1\n            ? `!${curr.declaration.split('!')[1]}`\n            : ''\n        }`]: value,\n      };\n    }\n    if (!isNestedPath(curr)) {\n      return {\n        ...prev,\n        ...flatten({\n          [curr.path]:\n            value !== null &&\n            (isPlainObject(value) || (Array.isArray(value) && value.length > 0))\n              ? flatten(value)\n              : value,\n        }),\n      };\n    }\n    if (Array.isArray(value)) {\n      return {\n        ...prev,\n        ...(flatten({\n          [curr.path]: value.map((v) => normalizeResponse(curr.paths, v)),\n        }) as R),\n      };\n    }\n    return {\n      ...prev,\n      ...flatten({\n        // add hint to path if it has dedupe alias\n        // can happen if the same relation is queried multiple times via different fkeys\n        [`${curr.path}${\n          curr.alias?.startsWith('d_') && curr.declaration.split('!').length > 1\n            ? `!${curr.declaration.split('!')[1]}`\n            : ''\n        }`]: normalizeResponse(curr.paths, value as Record<string, unknown>),\n      }),\n    };\n  }, {} as R);\n};\n\n/**\n * Build userQueryData from response\n *\n * note that `paths` is reflecting `obj`, not `userQueryPaths`.\n * iterate over `userQueryPaths` and find the corresponding path in `paths`.\n * Then, get value using the found alias and path from `obj`.\n **/\nconst buildUserQueryData = <R>(\n  userQueryGroups: (Path | NestedPath)[],\n  pathGroups: (Path | NestedPath)[],\n  obj: R,\n): R => {\n  if (pathGroups.some((p) => p.path === '*')) {\n    // if wildcard, add every non nested value\n    // for every nested value, check if pathGroups contains a nested path for it. if not, also add it.\n    // reason is that the wildcard does not select relations\n\n    Object.entries(obj as Record<string, unknown>).forEach(([k, v]) => {\n      if (typeof v === 'object' || Array.isArray(v)) {\n        if (!pathGroups.some((g) => isNestedPath(g) && g.path === k)) {\n          pathGroups.push({\n            path: k,\n            declaration: k,\n          });\n        }\n      } else if (!pathGroups.some((g) => g.path === k)) {\n        pathGroups.push({\n          path: k,\n          declaration: k,\n        });\n      }\n    });\n  }\n\n  if (userQueryGroups.some((p) => p.path === '*')) {\n    // if wildcard, add every non nested value\n    // for every nested value, check if pathGroups contains a nested path for it. if not, also add it.\n    // reason is that the wildcard does not select relations\n\n    Object.entries(obj as Record<string, unknown>).forEach(([k, v]) => {\n      if (typeof v === 'object' || Array.isArray(v)) {\n        if (!pathGroups.some((g) => isNestedPath(g) && g.path === k)) {\n          userQueryGroups.push({\n            path: k,\n            declaration: k,\n          });\n        }\n      } else if (!userQueryGroups.some((g) => g.path === k)) {\n        userQueryGroups.push({\n          path: k,\n          declaration: k,\n        });\n      }\n    });\n  }\n\n  return userQueryGroups.reduce<R>((prev, curr) => {\n    if (curr.path === '*') return prev;\n    // paths is reflecting the obj\n    const inputPath = pathGroups.find(\n      (p) => p.path === curr.path && isNestedPath(p) === isNestedPath(curr),\n    );\n    if (!inputPath) {\n      // should never happen though since userQueryPaths is a subset of paths\n      throw new Error(`Path ${curr.path} not found in response paths`);\n    }\n    const value = get(obj, inputPath.alias || inputPath.path);\n\n    if (typeof value === 'undefined') return prev;\n    if (value === null || !isNestedPath(curr) || !isNestedPath(inputPath)) {\n      (prev as Record<string, unknown>)[curr.alias ? curr.alias : curr.path] =\n        value;\n    } else if (Array.isArray(value)) {\n      (prev as Record<string, unknown>)[curr.alias ? curr.alias : curr.path] =\n        value.map((v) => buildUserQueryData(curr.paths, inputPath.paths, v));\n    } else {\n      (prev as Record<string, unknown>)[curr.alias ? curr.alias : curr.path] =\n        buildUserQueryData(\n          curr.paths,\n          inputPath.paths,\n          value as Record<string, unknown>,\n        );\n    }\n    return prev;\n  }, {} as R);\n};\n","/**\n * Parses a url and returns the table name the url is interacting with.\n *\n * For mutations, the .split('?') goes unused.\n *\n * @param url The url we are pulling the table name from\n * @returns Table name\n */\nexport const getTableFromUrl = (url: string): string => {\n  // Split the url\n  const split = url.toString().split('/');\n  // Pop the last part of the path off and remove any params if they exist\n  const table = split.pop()?.split('?').shift() as string;\n  // Pop an additional position to check for rpc\n  const maybeRpc = split.pop() as string;\n  // Rejoin the result to include rpc otherwise just table name\n  return [maybeRpc === 'rpc' ? maybeRpc : null, table]\n    .filter(Boolean)\n    .join('/');\n};\n","export type MaybeLikeQueryBuilder<Result> = unknown;\n\nexport type LikeQueryBuilder<Result> = {\n  url: URL;\n};\n\nexport const isLikeQueryBuilder = <Result>(\n  v: MaybeLikeQueryBuilder<Result>,\n): v is LikeQueryBuilder<Result> => {\n  if (typeof v !== 'object' || v === null) return false;\n  const obj = v as LikeQueryBuilder<Result>;\n\n  return typeof obj['url'] === 'object';\n};\n","import { getTableFromUrl } from './get-table-from-url';\nimport { MaybeLikePostgrestBuilder } from './like-postgrest-builder';\nimport { isLikeQueryBuilder } from './like-query-builder';\n\nexport const getTable = <Result>(\n  query: MaybeLikePostgrestBuilder<Result>,\n): string => {\n  if (!isLikeQueryBuilder(query)) {\n    throw new Error('Invalid PostgrestBuilder');\n  }\n\n  return getTableFromUrl(query['url'].pathname);\n};\n","import type { PostgrestHasMorePaginationResponse } from './response-types';\n\nexport type PostgrestPaginationCacheData<Result> = Result[][];\n\nexport const isPostgrestPaginationCacheData = <Result>(\n  q: unknown,\n): q is PostgrestPaginationCacheData<Result> => {\n  if (!Array.isArray(q)) return false;\n  return q.length === 0 || Array.isArray(q[0]);\n};\n\nexport type PostgrestHasMorePaginationCacheData<Result> =\n  PostgrestHasMorePaginationResponse<Result>[];\n\nexport const isPostgrestHasMorePaginationCacheData = <Result>(\n  q: unknown,\n): q is PostgrestHasMorePaginationCacheData<Result> => {\n  if (!Array.isArray(q)) return false;\n  if (q.length === 0) return true;\n  const firstPage = q[0];\n  return (\n    Array.isArray(\n      (firstPage as PostgrestHasMorePaginationResponse<Result>).data,\n    ) &&\n    typeof (firstPage as PostgrestHasMorePaginationResponse<Result>).hasMore ===\n      'boolean'\n  );\n};\n","import type {\n  PostgrestMaybeSingleResponse,\n  PostgrestResponse,\n  PostgrestSingleResponse,\n} from '@supabase/postgrest-js';\n\n// Convencience type to not bloat up implementation\nexport type AnyPostgrestResponse<Result> =\n  | PostgrestSingleResponse<Result>\n  | PostgrestMaybeSingleResponse<Result>\n  | PostgrestResponse<Result>;\n\nexport const isAnyPostgrestResponse = <Result>(\n  q: unknown,\n): q is AnyPostgrestResponse<Result> => {\n  if (!q) return false;\n  return (\n    typeof (q as AnyPostgrestResponse<Result>).data === 'object' ||\n    Array.isArray((q as AnyPostgrestResponse<Result>).data)\n  );\n};\n\nexport type PostgrestPaginationResponse<Result> = Result[];\n\nexport const isPostgrestPaginationResponse = <Result>(\n  q: unknown,\n): q is PostgrestPaginationResponse<Result> => {\n  return Array.isArray(q);\n};\n\nexport type PostgrestHasMorePaginationResponse<Result> = {\n  data: Result[];\n  hasMore: boolean;\n};\n\nexport const isPostgrestHasMorePaginationResponse = <Result>(\n  q: unknown,\n): q is PostgrestHasMorePaginationResponse<Result> => {\n  if (!q) return false;\n  return (\n    Array.isArray((q as PostgrestHasMorePaginationResponse<Result>).data) &&\n    typeof (q as PostgrestHasMorePaginationResponse<Result>).hasMore ===\n      'boolean'\n  );\n};\n","export const sortSearchParams = (params: URLSearchParams) =>\n  new URLSearchParams(\n    Array.from(params.entries()).sort((a, b) => {\n      const x = `${a[0]}${a[1]}`;\n      const y = `${b[0]}${b[1]}`;\n      return x > y ? 1 : -1;\n    }),\n  );\n","import { sortSearchParams } from './sort-search-param';\nimport { flatten, unflatten } from 'flat';\n\n/**\n * Encodes an object by url-encoding an ordered lists of all paths and their values.\n */\nexport const encodeObject = (obj: Record<string, unknown>): string => {\n  const sortedEntries = Object.entries(\n    flatten(obj) as Record<string, unknown>,\n  ).sort(([a], [b]) => a.length - b.length);\n  const bodyParams = new URLSearchParams();\n  sortedEntries.forEach(([key, value]) => {\n    bodyParams.append(key, String(value));\n  });\n  return sortSearchParams(bodyParams).toString();\n};\n\n/**\n * Decodes a URL-encoded string back into a nested object.\n * This is the reverse operation of encodeObject.\n */\nexport const decodeObject = (\n  encodedString: string,\n): Record<string, unknown> => {\n  const params = new URLSearchParams(encodedString);\n  const flatObject: Record<string, unknown> = {};\n\n  // Convert URLSearchParams back to a flat object\n  params.forEach((value, key) => {\n    // Try to convert string values to appropriate types\n    let parsedValue: unknown = value;\n\n    // Try to parse numbers\n    if (/^-?\\d+$/.test(value)) {\n      parsedValue = parseInt(value, 10);\n    } else if (/^-?\\d+\\.\\d+$/.test(value)) {\n      parsedValue = parseFloat(value);\n    } else if (value === 'true') {\n      parsedValue = true;\n    } else if (value === 'false') {\n      parsedValue = false;\n    } else if (value === 'null') {\n      parsedValue = null;\n    }\n\n    flatObject[key] = parsedValue;\n  });\n\n  // Unflatten the object to restore nested structure\n  return unflatten(flatObject);\n};\n","import type {\n  PostgrestBuilder,\n  PostgrestClientOptions,\n} from '@supabase/postgrest-js';\n\nexport const isPostgrestBuilder = <Result>(\n  q: unknown,\n): q is PostgrestBuilder<PostgrestClientOptions, Result> => {\n  return (\n    typeof (q as PostgrestBuilder<PostgrestClientOptions, Result>)\n      .throwOnError === 'function'\n  );\n};\n","import type { GenericSchema } from './postgrest-types';\nimport type {\n  PostgrestClientOptions,\n  PostgrestTransformBuilder,\n} from '@supabase/postgrest-js';\n\nexport const isPostgrestTransformBuilder = <\n  ClientOptions extends PostgrestClientOptions,\n  Schema extends GenericSchema,\n  Row extends Record<string, unknown>,\n  Result,\n  RelationName = unknown,\n  Relationships = unknown,\n>(\n  q: unknown,\n): q is PostgrestTransformBuilder<\n  ClientOptions,\n  Schema,\n  Row,\n  Result,\n  RelationName,\n  Relationships\n> => {\n  return (\n    typeof (\n      q as PostgrestTransformBuilder<\n        ClientOptions,\n        Schema,\n        Row,\n        Result,\n        RelationName,\n        Relationships\n      >\n    ).abortSignal === 'function'\n  );\n};\n","export const setFilterValue = (\n  searchParams: URLSearchParams,\n  path: string,\n  op: string,\n  value: string,\n) => {\n  const filters = searchParams.getAll(path);\n  // delete all\n  searchParams.delete(path);\n\n  // re-create\n  for (const f of filters) {\n    if (f.startsWith(`${op}.`)) {\n      continue;\n    }\n    searchParams.append(path, f);\n  }\n\n  searchParams.append(path, `${op}.${value}`);\n};\n","/**\n * Check if a value is a valid ISO DateTime string\n * @param v\n * @returns\n */\nexport const isISODateString = (v: unknown): boolean =>\n  typeof v === 'string' &&\n  /(\\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(\n    v,\n  );\n","import { isISODateString } from './is-iso-date-string';\nimport type { ValueType } from './query-types';\n\n/**\n * Safely parse any value to a ValueType\n * @param v Any value\n * @returns a ValueType\n */\nexport const parseValue = (v: any): ValueType => {\n  if (isISODateString(v)) return new Date(v);\n  try {\n    return JSON.parse(v);\n  } catch {\n    return v;\n  }\n};\n","import type { OrderDefinition } from './query-types';\n\n/**\n * Parses orderByKey back to OrderDefinition\n * @param key generated by PostgrestParser\n * @returns The parsed OrderDefinition\n */\nexport const parseOrderByKey = (v: string): OrderDefinition[] => {\n  return v.split('|').map((orderBy) => {\n    const [tableDef, orderDef] = orderBy.split(':');\n    const [foreignTableOrCol, maybeCol] = tableDef.split('.');\n    const [dir, nulls] = orderDef.split('.');\n    return {\n      ascending: dir === 'asc',\n      nullsFirst: nulls === 'nullsFirst',\n      foreignTable: maybeCol ? foreignTableOrCol : undefined,\n      column: maybeCol ? maybeCol : foreignTableOrCol,\n    };\n  });\n};\n","import { OrderDefinition } from './query-types';\n\nexport const parseOrderBy = (searchParams: URLSearchParams) => {\n  const orderBy: OrderDefinition[] = [];\n  searchParams.forEach((value, key) => {\n    const split = key.split('.');\n    if (split[split.length === 2 ? 1 : 0] === 'order') {\n      // separated by ,\n      const orderByDefs = value.split(',');\n      orderByDefs.forEach((def) => {\n        const [column, ascending, nullsFirst] = def.split('.');\n        orderBy.push({\n          ascending: ascending === 'asc',\n          column,\n          nullsFirst: nullsFirst === 'nullsfirst',\n          foreignTable: split.length === 2 ? split[0] : undefined,\n        });\n      });\n    }\n  });\n\n  return orderBy;\n};\n","import {\n  type FilterDefinition,\n  type FilterDefinitions,\n  isAndFilter,\n  isFilterDefinition,\n  isOrFilter,\n} from './query-types';\n\n// Helper to search for filters in a filter definition\nexport const findFilters = (\n  f: FilterDefinitions,\n  by: Partial<FilterDefinition>,\n) => {\n  const filters: FilterDefinition[] = [];\n  f.forEach((filter) => {\n    if (isAndFilter(filter)) {\n      filters.push(...findFilters(filter.and, by));\n    }\n    if (isOrFilter(filter)) {\n      filters.push(...findFilters(filter.or, by));\n    }\n    if (isFilterDefinition(filter)) {\n      if (\n        (typeof by.path === 'undefined' || filter.path === by.path) &&\n        (typeof by.alias === 'undefined' || filter.alias === by.alias) &&\n        (typeof by.value === 'undefined' || filter.value === by.value) &&\n        (typeof by.negate === 'undefined' || filter.negate === by.negate) &&\n        (typeof by.operator === 'undefined' || filter.operator === by.operator)\n      ) {\n        filters.push(filter);\n      }\n    }\n  });\n  return filters;\n};\n","import { isPlainObject } from './lib/is-plain-object';\nimport { parseOrderBy } from './lib/parse-order-by';\nimport { GenericSchema } from './lib/postgrest-types';\nimport type { PostgrestPaginationResponse } from './lib/response-types';\nimport type {\n  PostgrestClientOptions,\n  PostgrestTransformBuilder,\n} from '@supabase/postgrest-js';\n\nexport type PostgrestCursorPaginationFetcher<Type, Args> = (\n  args: Args,\n) => Promise<Type>;\n\nexport type PostgrestCursorPaginationKeyDecoder<Args> = (args: Args) => {\n  orderBy?: string;\n  uqOrderBy?: string;\n};\n\nexport const createCursorPaginationFetcher = <\n  Options extends PostgrestClientOptions,\n  Schema extends GenericSchema,\n  Row extends Record<string, unknown>,\n  Result,\n  Args,\n  Relationships = unknown,\n>(\n  queryFactory:\n    | (() => PostgrestTransformBuilder<\n        Options,\n        Schema,\n        Row,\n        Result[],\n        Relationships\n      >)\n    | null,\n  config: {\n    decode: PostgrestCursorPaginationKeyDecoder<Args>;\n    orderBy: string;\n    uqOrderBy?: string;\n    rpcArgs?: { orderBy: string; uqOrderBy?: string };\n  },\n): PostgrestCursorPaginationFetcher<\n  PostgrestPaginationResponse<Result>,\n  Args\n> | null => {\n  if (!queryFactory) return null;\n  return async (args) => {\n    const cursor = config.decode(args);\n\n    const query = queryFactory();\n\n    if (config.rpcArgs) {\n      if (query['method'] === 'GET') {\n        if (cursor.orderBy) {\n          query['url'].searchParams.set(config.rpcArgs.orderBy, cursor.orderBy);\n        }\n        if (config.rpcArgs.uqOrderBy && cursor.uqOrderBy) {\n          query['url'].searchParams.set(\n            config.rpcArgs.uqOrderBy,\n            cursor.uqOrderBy,\n          );\n        }\n      } else {\n        query['body'] = {\n          ...(isPlainObject(query['body']) ? query['body'] : {}),\n          [config.rpcArgs.orderBy]: cursor.orderBy,\n          ...(cursor.uqOrderBy && config.rpcArgs.uqOrderBy\n            ? { [config.rpcArgs.uqOrderBy]: cursor.uqOrderBy }\n            : {}),\n        };\n      }\n\n      const { data } = await query.throwOnError();\n\n      // cannot be null because of .throwOnError()\n      return data as Result[];\n    }\n\n    const orderByDef = parseOrderBy(query['url'].searchParams);\n    const orderBy = orderByDef.find((o) => o.column === config.orderBy);\n\n    if (!orderBy) {\n      throw new Error(`No ordering key found for path ${config.orderBy}`);\n    }\n\n    const uqOrderBy = config.uqOrderBy\n      ? orderByDef.find((o) => o.column === config.uqOrderBy)\n      : null;\n\n    if (cursor.orderBy && config.uqOrderBy && cursor.uqOrderBy && uqOrderBy) {\n      const operator = orderBy.ascending ? 'gt' : 'lt';\n      const uqOperator = uqOrderBy.ascending ? 'gt' : 'lt';\n\n      query['url'].searchParams.append(\n        'or',\n        `(${config.orderBy}.${operator}.\"${cursor.orderBy}\",and(${config.orderBy}.eq.\"${cursor.orderBy}\",${config.uqOrderBy}.${uqOperator}.\"${cursor.uqOrderBy}\"))`,\n      );\n    } else if (cursor.orderBy) {\n      const operator = orderBy.ascending ? 'gt' : 'lt';\n      query['url'].searchParams.append(\n        config.orderBy,\n        `${operator}.${cursor.orderBy}`,\n      );\n    }\n\n    const { data, error } = await query;\n\n    if (error) throw error;\n\n    // cannot be null because of .throwOnError()\n    return data as Result[];\n  };\n};\n","import {\n  type MutationFetcherResponse,\n  buildMutationFetcherResponse,\n} from './fetch/build-mutation-fetcher-response';\nimport {\n  type BuildNormalizedQueryOps,\n  buildNormalizedQuery,\n} from './fetch/build-normalized-query';\nimport { GenericSchema, GenericTable } from './lib/postgrest-types';\nimport type {\n  PostgrestClientOptions,\n  PostgrestQueryBuilder,\n} from '@supabase/postgrest-js';\nimport { UnstableGetResult as GetResult } from '@supabase/postgrest-js';\n\nexport type DeleteFetcher<T extends GenericTable, R> = (\n  input: Partial<T['Row']>[],\n) => Promise<MutationFetcherResponse<R>[] | null>;\n\nexport type DeleteFetcherOptions<\n  O extends PostgrestClientOptions,\n  S extends GenericSchema,\n  T extends GenericTable,\n  Re = T extends { Relationships: infer R } ? R : unknown,\n> = Parameters<PostgrestQueryBuilder<O, S, T, Re>['delete']>[0];\n\nexport const buildDeleteFetcher =\n  <\n    O extends PostgrestClientOptions,\n    S extends GenericSchema,\n    T extends GenericTable,\n    RelationName,\n    Re = T extends { Relationships: infer R } ? R : unknown,\n    Q extends string = '*',\n    R = GetResult<S, T['Row'], RelationName, Re, Q extends '*' ? '*' : Q, O>,\n  >(\n    qb: PostgrestQueryBuilder<O, S, T, R>,\n    primaryKeys: (keyof T['Row'])[],\n    opts: BuildNormalizedQueryOps<Q> &\n      DeleteFetcherOptions<O, S, T, RelationName>,\n  ): DeleteFetcher<T, R> =>\n  async (\n    input: Partial<T['Row']>[],\n  ): Promise<MutationFetcherResponse<R>[] | null> => {\n    let filterBuilder = qb.delete(opts);\n\n    if (primaryKeys.length === 1) {\n      const primaryKey = primaryKeys[0] as string;\n      filterBuilder.in(\n        primaryKey,\n        input.map((i) => {\n          const v = i[primaryKey];\n          if (!v) {\n            throw new Error(\n              `Missing value for primary key ${primaryKey as string}`,\n            );\n          }\n          return v;\n          // TODO i wont bother with this, but maybe i can nerdsnipe somone else into it\n        }) as any[],\n      );\n    } else {\n      filterBuilder = filterBuilder.or(\n        input\n          .map(\n            (i) =>\n              `and(${primaryKeys.map((c) => {\n                const v = i[c];\n                if (!v) {\n                  throw new Error(\n                    `Missing value for primary key ${c as string}`,\n                  );\n                }\n                return `${c as string}.eq.${v}`;\n              })})`,\n          )\n          .join(','),\n      );\n    }\n\n    const primaryKeysData = input.map((i) =>\n      primaryKeys.reduce<R>((prev, key) => {\n        return {\n          ...prev,\n          [key]: i[key],\n        };\n      }, {} as R),\n    );\n\n    const query = buildNormalizedQuery<Q>(opts);\n    if (query) {\n      const { selectQuery, groupedUserQueryPaths, groupedPaths } = query;\n      // make sure that primary keys are included in the select query\n      const groupedPathsWithPrimaryKeys = groupedPaths;\n      const addKeys: string[] = [];\n      primaryKeys.forEach((key) => {\n        if (!groupedPathsWithPrimaryKeys.find((p) => p.path === key)) {\n          groupedPathsWithPrimaryKeys.push({\n            declaration: key as string,\n            path: key as string,\n          });\n          addKeys.push(key as string);\n        }\n      });\n      const { data } = await filterBuilder\n        .select([selectQuery, ...addKeys].join(','))\n        .throwOnError();\n      return (data as R[]).map((d) =>\n        buildMutationFetcherResponse(d, {\n          groupedPaths: groupedPathsWithPrimaryKeys,\n          groupedUserQueryPaths,\n        }),\n      );\n    }\n\n    await filterBuilder.throwOnError();\n\n    if (opts.queriesForTable().length > 0) {\n      // if there is at least one query on the table we are deleting from, return primary keys\n      return primaryKeysData.map((pk) => ({ normalizedData: pk }));\n    }\n\n    return null;\n  };\n","import type { PostgrestFilter } from '../postgrest-filter';\nimport type { PostgrestQueryParserOptions } from '../postgrest-query-parser';\nimport type { DecodedKey } from './types';\n\nexport type RevalidateRelationOpt<Type> = {\n  schema?: string;\n  relation: string;\n  relationIdColumn: string;\n  fKeyColumn: keyof Type;\n};\n\nexport type RevalidateRelations<Type extends Record<string, unknown>> =\n  RevalidateRelationOpt<Type>[];\n\nexport type RevalidateRelationsProps<Type extends Record<string, unknown>> = {\n  input: Partial<Type>;\n  decodedKey: Pick<DecodedKey, 'schema' | 'table' | 'queryKey'>;\n  getPostgrestFilter: (\n    query: string,\n    opts?: PostgrestQueryParserOptions,\n  ) => Pick<PostgrestFilter<Type>, 'applyFilters'>;\n};\n\nexport const shouldRevalidateRelation = <Type extends Record<string, unknown>>(\n  relations: RevalidateRelations<Type>,\n  {\n    input,\n    getPostgrestFilter,\n    decodedKey: { schema, table, queryKey },\n  }: RevalidateRelationsProps<Type>,\n): boolean =>\n  Boolean(\n    relations.find(\n      (r) =>\n        (!r.schema || r.schema === schema) &&\n        r.relation === table &&\n        typeof input[r.fKeyColumn] !== 'undefined' &&\n        getPostgrestFilter(queryKey, {\n          exclusivePaths: [r.relationIdColumn],\n        }).applyFilters({\n          [r.relationIdColumn]: input[r.fKeyColumn],\n        }),\n    ),\n  );\n","import type { DecodedKey } from './types';\n\nexport type RevalidateTableOpt = { schema?: string; table: string };\n\nexport type RevalidateTables = RevalidateTableOpt[];\n\nexport type RevalidateTablesProps = {\n  decodedKey: Pick<DecodedKey, 'schema' | 'table'>;\n};\n\nexport const shouldRevalidateTable = (\n  tables: RevalidateTables,\n  { decodedKey: { schema, table } }: RevalidateTablesProps,\n): boolean =>\n  Boolean(\n    tables.find((t) => (!t.schema || t.schema === schema) && t.table === table),\n  );\n","import type {\n  PostgrestHasMorePaginationCacheData,\n  PostgrestPaginationCacheData,\n} from '../lib/cache-data-types';\n\nexport const toHasMorePaginationCacheData = <\n  Type extends Record<string, unknown>,\n>(\n  a: Type[],\n  currentData: PostgrestHasMorePaginationCacheData<Type>,\n  chunkSize: number,\n) => {\n  // return array in chunks\n  const hasMoreCache = currentData.map((p) => p.hasMore);\n  return a.reduce<PostgrestHasMorePaginationCacheData<Type>>(\n    (resultArray, item, index) => {\n      // default limit is 1000\n      // ref: https://github.com/supabase/supabase/discussions/3765#discussioncomment-1581021\n      const chunkIndex = Math.floor(index / chunkSize);\n\n      if (!resultArray[chunkIndex]) {\n        let hasMore = hasMoreCache[chunkIndex];\n        if (!hasMore) {\n          // if new page, set to hasMore of last page\n          hasMore = hasMoreCache[hasMoreCache.length - 1];\n        }\n        if (chunkIndex > 0) {\n          // if not first page, set prev has more to true\n          resultArray[chunkIndex - 1].hasMore = true;\n        }\n        resultArray[chunkIndex] = {\n          data: [],\n          hasMore:\n            hasMoreCache[chunkIndex] ??\n            hasMoreCache[hasMoreCache.length - 1] ??\n            false,\n        }; // start a new chunk\n      }\n\n      resultArray[chunkIndex].data.push(item);\n\n      return resultArray;\n    },\n    [],\n  );\n};\n\nexport const toPaginationCacheData = <Type extends Record<string, unknown>>(\n  a: Type[],\n  chunkSize: number,\n) => {\n  return a.reduce<PostgrestPaginationCacheData<Type>>(\n    (resultArray, item, index) => {\n      // default limit is 1000\n      // ref: https://github.com/supabase/supabase/discussions/3765#discussioncomment-1581021\n      const chunkIndex = Math.floor(index / chunkSize);\n\n      if (!resultArray[chunkIndex]) {\n        resultArray[chunkIndex] = []; // start a new chunk\n      }\n\n      resultArray[chunkIndex].push(item);\n\n      return resultArray;\n    },\n    [],\n  );\n};\n","import {\n  isPostgrestHasMorePaginationCacheData,\n  isPostgrestPaginationCacheData,\n} from './lib/cache-data-types';\nimport { isAnyPostgrestResponse } from './lib/response-types';\nimport { shouldRevalidateRelation } from './mutate/should-revalidate-relation';\nimport { shouldRevalidateTable } from './mutate/should-revalidate-table';\nimport {\n  toHasMorePaginationCacheData,\n  toPaginationCacheData,\n} from './mutate/transformers';\nimport type { DecodedKey, MutatorFn, RevalidateOpts } from './mutate/types';\nimport type { PostgrestFilter } from './postgrest-filter';\nimport type { PostgrestQueryParserOptions } from './postgrest-query-parser';\n\nconst filterByPks = <Type extends Record<string, unknown>>(\n  input: Type,\n  currentData: Type[],\n  primaryKeys: (keyof Type)[],\n) => {\n  return currentData.filter((i) =>\n    primaryKeys.some((pk) => i[pk] !== input[pk]),\n  );\n};\n\nexport type DeleteItemOperation<Type extends Record<string, unknown>> = {\n  table: string;\n  schema: string;\n  input: Type;\n  primaryKeys: (keyof Type)[];\n} & RevalidateOpts<Type>;\n\nexport type DeleteItemCache<KeyType, Type extends Record<string, unknown>> = {\n  /**\n   * The keys currently present in the cache\n   */\n  cacheKeys: KeyType[];\n  /**\n   * Should return a PostgrestFilter for the given query.\n   * This is exposed as a function so results can be cached by the cache library.\n   */\n  getPostgrestFilter: (\n    query: string,\n    opts?: PostgrestQueryParserOptions,\n  ) => Pick<PostgrestFilter<Type>, 'applyFilters' | 'denormalize'>;\n  /**\n   * Decode a key. Should return null if not a PostgREST key.\n   */\n  decode: (k: KeyType) => DecodedKey | null;\n  /**\n   * The mutation function from the cache library\n   */\n  mutate: (key: KeyType, fn: MutatorFn<Type>) => Promise<void> | void;\n  /**\n   * The revalidation function from the cache library\n   */\n  revalidate: (key: KeyType) => Promise<void> | void;\n};\n\nexport const deleteItem = async <KeyType, Type extends Record<string, unknown>>(\n  op: DeleteItemOperation<Type>,\n  cache: DeleteItemCache<KeyType, Type>,\n) => {\n  const {\n    revalidateRelations: revalidateRelationsOpt,\n    revalidateTables: revalidateTablesOpt,\n    schema,\n    table,\n  } = op;\n  const { cacheKeys, decode, getPostgrestFilter, mutate, revalidate } = cache;\n\n  const mutations = [];\n  for (const k of cacheKeys) {\n    const key = decode(k);\n\n    // Exit early if not a postgrest key\n    if (!key) continue;\n    const filter = getPostgrestFilter(key.queryKey);\n    // parse input into expected target format\n    if (key.schema === schema && key.table === table) {\n      if (key.isHead === true) {\n        mutations.push(revalidate(k));\n      } else {\n        const transformedInput = filter.denormalize(op.input);\n        if (\n          // For delete, the input has to have a value for all primary keys\n          op.primaryKeys.every(\n            (pk) => typeof transformedInput[pk as string] !== 'undefined',\n          )\n        ) {\n          const limit = key.limit ?? 1000;\n          mutations.push(\n            mutate(k, (currentData) => {\n              // Return early if undefined or null\n              if (!currentData) return currentData;\n\n              if (isPostgrestHasMorePaginationCacheData<Type>(currentData)) {\n                return toHasMorePaginationCacheData(\n                  filterByPks<Type>(\n                    transformedInput,\n                    currentData.flatMap((p) => p.data),\n                    op.primaryKeys,\n                  ),\n                  currentData,\n                  limit,\n                );\n              } else if (isPostgrestPaginationCacheData<Type>(currentData)) {\n                return toPaginationCacheData(\n                  filterByPks<Type>(\n                    transformedInput,\n                    currentData.flat(),\n                    op.primaryKeys,\n                  ),\n                  limit,\n                );\n              } else if (isAnyPostgrestResponse<Type>(currentData)) {\n                const { data } = currentData;\n                if (!Array.isArray(data)) {\n                  if (\n                    data &&\n                    op.primaryKeys.some(\n                      (pk) => transformedInput[pk] !== data[pk],\n                    )\n                  ) {\n                    return currentData;\n                  } else {\n                    return { data: null };\n                  }\n                }\n\n                const newData = filterByPks(\n                  transformedInput,\n                  data,\n                  op.primaryKeys,\n                );\n\n                return {\n                  data: newData,\n                  count: newData.length,\n                };\n              }\n            }),\n          );\n        }\n      }\n    }\n\n    if (\n      revalidateTablesOpt &&\n      shouldRevalidateTable(revalidateTablesOpt, { decodedKey: key })\n    ) {\n      mutations.push(revalidate(k));\n    }\n\n    if (\n      revalidateRelationsOpt &&\n      shouldRevalidateRelation(revalidateRelationsOpt, {\n        input: op.input,\n        getPostgrestFilter,\n        decodedKey: key,\n      })\n    ) {\n      mutations.push(revalidate(k));\n    }\n  }\n\n  await Promise.all(mutations);\n};\n","import { isPostgrestBuilder } from './lib/is-postgrest-builder';\nimport type { AnyPostgrestResponse } from './lib/response-types';\n\nexport const fetcher = async <Result>(\n  q: PromiseLike<AnyPostgrestResponse<Result>>,\n) => {\n  if (isPostgrestBuilder(q)) {\n    q = q.throwOnError();\n  }\n  return await q;\n};\n","import {\n  type MutationFetcherResponse,\n  buildMutationFetcherResponse,\n} from './fetch/build-mutation-fetcher-response';\nimport {\n  type BuildNormalizedQueryOps,\n  buildNormalizedQuery,\n} from './fetch/build-normalized-query';\nimport { GenericSchema, GenericTable } from './lib/postgrest-types';\nimport type {\n  PostgrestClientOptions,\n  PostgrestQueryBuilder,\n} from '@supabase/postgrest-js';\nimport { UnstableGetResult as GetResult } from '@supabase/postgrest-js';\n\nexport type InsertFetcher<T extends GenericTable, R> = (\n  input: T['Insert'][],\n) => Promise<MutationFetcherResponse<R>[] | null>;\n\nexport type InsertFetcherOptions<\n  O extends PostgrestClientOptions,\n  S extends GenericSchema,\n  T extends GenericTable,\n  Re = T extends { Relationships: infer R } ? R : unknown,\n> = Parameters<PostgrestQueryBuilder<O, S, T, Re>['insert']>[1];\n\nfunction buildInsertFetcher<\n  O extends PostgrestClientOptions,\n  S extends GenericSchema,\n  T extends GenericTable,\n  RelationName,\n  Re = T extends { Relationships: infer R } ? R : unknown,\n  Q extends string = '*',\n  R = GetResult<S, T['Row'], RelationName, Re, Q extends '*' ? '*' : Q, O>,\n>(\n  qb: PostgrestQueryBuilder<O, S, T, Re>,\n  opts: BuildNormalizedQueryOps<Q> & InsertFetcherOptions<O, S, T, Re>,\n): InsertFetcher<T, R> {\n  return async (\n    input: T['Insert'][],\n  ): Promise<MutationFetcherResponse<R>[] | null> => {\n    const query = buildNormalizedQuery<Q>(opts);\n    if (query) {\n      const { selectQuery, groupedUserQueryPaths, groupedPaths } = query;\n      const { data } = await qb\n        .insert(input as any, opts)\n        .select(selectQuery)\n        .throwOnError();\n      // data cannot be null because of throwOnError()\n      return (data as R[]).map((d) =>\n        buildMutationFetcherResponse(d, {\n          groupedUserQueryPaths,\n          groupedPaths,\n        }),\n      );\n    }\n    await qb.insert(input as any).throwOnError();\n    return input.map((d) => ({ normalizedData: d as R }));\n  };\n}\n\nexport { buildInsertFetcher };\n","/*\n * Binary search in JavaScript.\n * Returns the index of of the element in a sorted array or (-n-1) where n is the insertion point for the new element.\n * Parameters:\n *     ar - A sorted array\n *     el - An element to search for\n *     compare - A comparator function. The function takes two arguments: (a, b) and returns:\n *        a negative number  if a is less than b;\n *        0 if a is equal to b;\n *        a positive number of a is greater than b.\n * The array may contain duplicate elements. If there are more than one equal elements in the array,\n * the returned value can be the index of any one of the equal elements.\n */\nexport function binarySearch<Type>(\n  arr: Type[],\n  el: Type,\n  compare: (a: Type, b: Type) => number,\n) {\n  let m = 0;\n  let n = arr.length - 1;\n  while (m <= n) {\n    const k = (n + m) >> 1;\n    const cmp = compare(el, arr[k]);\n    if (cmp > 0) {\n      m = k + 1;\n    } else if (cmp < 0) {\n      n = k - 1;\n    } else {\n      return k;\n    }\n  }\n  return m;\n}\n","export const ifDateGetTime = (v: unknown) => {\n  if (v instanceof Date) return v.getTime();\n  if (typeof v === 'string') {\n    const t = new Date(v).getTime();\n    if (!isNaN(t)) return t;\n  }\n  return v;\n};\n","import { get as defaultGet } from './get';\nimport { ifDateGetTime } from './if-date-get-time';\nimport type { OrderDefinition } from './query-types';\n\nexport const buildSortedComparator = <Type extends Record<string, unknown>>(\n  orderBy: OrderDefinition[],\n) => {\n  return (a: Type, b: Type) => {\n    for (const { column, ascending, nullsFirst, foreignTable } of orderBy) {\n      const aValue = ifDateGetTime(\n        defaultGet(\n          a,\n          `${foreignTable ? `${foreignTable}.` : ''}${column}`,\n          null,\n        ),\n      );\n\n      const bValue = ifDateGetTime(\n        defaultGet(\n          b,\n          `${foreignTable ? `${foreignTable}.` : ''}${column}`,\n          null,\n        ),\n      );\n\n      // go to next if value is equals\n      if (aValue === bValue) continue;\n\n      // nullsFirst / nullsLast\n      if (aValue === null || aValue === undefined) {\n        return nullsFirst ? -1 : 1;\n      }\n\n      if (bValue === null || bValue === undefined) {\n        return nullsFirst ? 1 : -1;\n      }\n\n      // otherwise, if we're ascending, lowest sorts first\n      if (ascending) {\n        return aValue < bValue ? -1 : 1;\n      }\n\n      // if descending, highest sorts first\n      return aValue < bValue ? 1 : -1;\n    }\n\n    return 0;\n  };\n};\n","import { binarySearch } from './binary-search';\nimport type { OrderDefinition } from './query-types';\nimport { buildSortedComparator } from './sorted-comparator';\n\nexport const findIndexOrdered = <Type extends Record<string, unknown>>(\n  input: Type,\n  currentData: Type[],\n  orderBy: OrderDefinition[],\n): number => binarySearch(currentData, input, buildSortedComparator(orderBy));\n","import {\n  isPostgrestHasMorePaginationCacheData,\n  isPostgrestPaginationCacheData,\n} from './lib/cache-data-types';\nimport { findIndexOrdered } from './lib/find-index-ordered';\nimport { parseOrderByKey } from './lib/parse-order-by-key';\nimport type { OrderDefinition } from './lib/query-types';\nimport { isAnyPostgrestResponse } from './lib/response-types';\nimport { shouldRevalidateRelation } from './mutate/should-revalidate-relation';\nimport { shouldRevalidateTable } from './mutate/should-revalidate-table';\nimport {\n  toHasMorePaginationCacheData,\n  toPaginationCacheData,\n} from './mutate/transformers';\nimport type { DecodedKey, MutatorFn, RevalidateOpts } from './mutate/types';\nimport type { PostgrestFilter } from './postgrest-filter';\nimport type { PostgrestQueryParserOptions } from './postgrest-query-parser';\n\nexport const mutateOperation = <Type extends Record<string, unknown>>(\n  input: Partial<Type>,\n  mutate: (current: Type) => Type,\n  currentData: Type[],\n  primaryKeys: (keyof Type)[],\n  filter: Pick<PostgrestFilter<Type>, 'apply'>,\n  orderBy?: OrderDefinition[],\n) => {\n  // find item\n  const itemIdx = currentData.findIndex((oldItem) =>\n    primaryKeys.every((pk) => oldItem[pk] === input[pk]),\n  );\n\n  if (itemIdx === -1) {\n    // if not exists, do nothing\n    return currentData;\n  }\n\n  let newItemIdx = itemIdx;\n  const newItem = mutate(currentData[newItemIdx]);\n\n  // if exists, remove\n  currentData.splice(itemIdx, 1);\n\n  if (orderBy && Array.isArray(orderBy) && orderBy.length > 0) {\n    // if ordered, find new idx\n    newItemIdx = findIndexOrdered(newItem, currentData, orderBy);\n  }\n\n  if (newItemIdx === -1) {\n    // default to prepend\n    newItemIdx = 0;\n  }\n\n  // check that new item is still a valid member of the list and has all required paths\n  if (filter.apply(newItem)) {\n    currentData.splice(newItemIdx, 0, newItem);\n  }\n\n  return currentData;\n};\n\nexport type MutateItemOperation<Type extends Record<string, unknown>> = {\n  table: string;\n  schema: string;\n  input: Partial<Type>;\n  mutate: (current: Type) => Type;\n  primaryKeys: (keyof Type)[];\n} & RevalidateOpts<Type>;\n\nexport type MutateItemCache<KeyType, Type extends Record<string, unknown>> = {\n  /**\n   * The keys currently present in the cache\n   */\n  cacheKeys: KeyType[];\n  /**\n   * Should return a PostgrestFilter for the given query.\n   * This is exposed as a function so results can be cached by the cache library.\n   */\n  getPostgrestFilter: (\n    query: string,\n    opts?: PostgrestQueryParserOptions,\n  ) => Pick<\n    PostgrestFilter<Type>,\n    | 'applyFilters'\n    | 'denormalize'\n    | 'hasFiltersOnPaths'\n    | 'applyFiltersOnPaths'\n    | 'apply'\n    | 'hasWildcardPath'\n    | 'hasAggregatePath'\n  >;\n  /**\n   * Decode a key. Should return null if not a PostgREST key.\n   */\n  decode: (k: KeyType) => DecodedKey | null;\n  /**\n   * The mutation function from the cache library\n   */\n  mutate: (key: KeyType, fn: MutatorFn<Type>) => Promise<void> | void;\n  /**\n   * The revalidation function from the cache library\n   */\n  revalidate: (key: KeyType) => Promise<void> | void;\n};\n\nexport const mutateItem = async <KeyType, Type extends Record<string, unknown>>(\n  op: MutateItemOperation<Type>,\n  cache: MutateItemCache<KeyType, Type>,\n) => {\n  const {\n    mutate: mutateInput,\n    revalidateRelations: revalidateRelationsOpt,\n    revalidateTables: revalidateTablesOpt,\n    schema,\n    table,\n    primaryKeys,\n  } = op;\n  const { cacheKeys, decode, getPostgrestFilter, mutate, revalidate } = cache;\n\n  const mutations = [];\n  for (const k of cacheKeys) {\n    const key = decode(k);\n\n    // Exit early if not a postgrest key\n    if (!key) continue;\n    const filter = getPostgrestFilter(key.queryKey);\n    if (key.schema === schema && key.table === table) {\n      // parse input into expected target format\n      const transformedInput = filter.denormalize(op.input);\n      if (\n        // For mutate, the input has to have a value for all primary keys\n        op.primaryKeys.every(\n          (pk) => typeof transformedInput[pk as string] !== 'undefined',\n        ) && // allow mutate if either the filter does not apply eq filters on any pk\n        (!filter.hasFiltersOnPaths(op.primaryKeys as string[]) ||\n          // or input matches all pk filters\n          filter.applyFiltersOnPaths(\n            transformedInput,\n            op.primaryKeys as string[],\n          ))\n      ) {\n        const limit = key.limit ?? 1000;\n        const orderBy = key.orderByKey\n          ? parseOrderByKey(key.orderByKey)\n          : undefined;\n        if (\n          key.isHead === true ||\n          filter.hasWildcardPath ||\n          filter.hasAggregatePath\n        ) {\n          // we cannot know whether the new item after mutating still has all paths required for a query if it contains a wildcard,\n          // because we do not know what columns a table has. we must always revalidate then.\n          mutations.push(revalidate(k));\n        } else {\n          mutations.push(\n            mutate(k, (currentData) => {\n              // Return early if undefined or null\n              if (!currentData) return currentData;\n\n              if (isPostgrestHasMorePaginationCacheData<Type>(currentData)) {\n                return toHasMorePaginationCacheData(\n                  mutateOperation<Type>(\n                    transformedInput,\n                    mutateInput,\n                    currentData.flatMap((p) => p.data),\n                    primaryKeys,\n                    filter,\n                    orderBy,\n                  ),\n                  currentData,\n                  limit,\n                );\n              } else if (isPostgrestPaginationCacheData<Type>(currentData)) {\n                return toPaginationCacheData(\n                  mutateOperation<Type>(\n                    transformedInput,\n                    mutateInput,\n                    currentData.flat(),\n                    primaryKeys,\n                    filter,\n                    orderBy,\n                  ),\n                  limit,\n                );\n              } else if (isAnyPostgrestResponse<Type>(currentData)) {\n                const { data } = currentData;\n\n                if (!Array.isArray(data)) {\n                  if (data === null) {\n                    return {\n                      data,\n                      count: currentData.count,\n                    };\n                  }\n                  const newData = mutateInput(data);\n                  return {\n                    // Check if the new data is still valid given the key\n                    data: filter.apply(newData) ? newData : null,\n                    count: currentData.count,\n                  };\n                }\n\n                const newData = mutateOperation<Type>(\n                  transformedInput,\n                  mutateInput,\n                  // deep copy data to avoid mutating the original\n                  JSON.parse(JSON.stringify(data)),\n                  primaryKeys,\n                  filter,\n                  orderBy,\n                );\n\n                return {\n                  data: newData,\n                  count: newData.length,\n                };\n              }\n              return currentData;\n            }),\n          );\n        }\n      }\n    }\n\n    if (\n      revalidateTablesOpt &&\n      shouldRevalidateTable(revalidateTablesOpt, { decodedKey: key })\n    ) {\n      mutations.push(revalidate(k));\n    }\n\n    if (\n      revalidateRelationsOpt &&\n      shouldRevalidateRelation(revalidateRelationsOpt, {\n        input: op.input,\n        getPostgrestFilter,\n        decodedKey: key,\n      })\n    ) {\n      mutations.push(revalidate(k));\n    }\n  }\n  await Promise.all(mutations);\n};\n","import { isPlainObject } from './lib/is-plain-object';\nimport { GenericSchema } from './lib/postgrest-types';\nimport type {\n  PostgrestHasMorePaginationResponse,\n  PostgrestPaginationResponse,\n} from './lib/response-types';\nimport type {\n  PostgrestClientOptions,\n  PostgrestTransformBuilder,\n} from '@supabase/postgrest-js';\n\nexport type PostgrestOffsetPaginationFetcher<Type, Args> = (\n  args: Args,\n) => Promise<Type>;\n\nexport type PostgrestOffsetPaginationKeyDecoder<Args> = (args: Args) => {\n  limit?: number;\n  offset?: number;\n};\n\nexport const createOffsetPaginationFetcher = <\n  Options extends PostgrestClientOptions,\n  Schema extends GenericSchema,\n  Row extends Record<string, unknown>,\n  Result,\n  Args,\n  RelationName = unknown,\n  Relationships = unknown,\n>(\n  queryFactory:\n    | (() => PostgrestTransformBuilder<\n        Options,\n        Schema,\n        Row,\n        Result[],\n        Relationships\n      >)\n    | null,\n  {\n    decode,\n    pageSize,\n    rpcArgs,\n  }: {\n    decode: PostgrestOffsetPaginationKeyDecoder<Args>;\n    pageSize: number;\n    rpcArgs?: { limit: string; offset: string };\n  },\n): PostgrestOffsetPaginationFetcher<\n  PostgrestPaginationResponse<Result>,\n  Args\n> | null => {\n  if (!queryFactory) return null;\n\n  return async (args) => {\n    const decodedKey = decode(args);\n    const limit = decodedKey.limit ? decodedKey.limit : pageSize;\n    const offset = decodedKey.offset ?? 0;\n\n    const query = queryFactory();\n\n    return rpcArgs\n      ? await rpcOffsetPaginationFetcher<\n          Options,\n          Schema,\n          Row,\n          Result,\n          RelationName,\n          Relationships\n        >(query, { limit, offset, rpcArgs })\n      : await offsetPaginationFetcher<\n          Options,\n          Schema,\n          Row,\n          Result,\n          RelationName,\n          Relationships\n        >(query, { limit, offset });\n  };\n};\n\nexport const offsetPaginationFetcher = async <\n  Options extends PostgrestClientOptions,\n  Schema extends GenericSchema,\n  Row extends Record<string, unknown>,\n  Result,\n  RelationName = unknown,\n  Relationships = unknown,\n>(\n  query: PostgrestTransformBuilder<\n    Options,\n    Schema,\n    Row,\n    Result[],\n    RelationName,\n    Relationships\n  >,\n  { limit, offset }: { limit: number; offset: number },\n) => {\n  const { data } = await query.range(offset, offset + limit - 1).throwOnError();\n  // cannot be null because of .throwOnError()\n  return data as Result[];\n};\n\nexport const rpcOffsetPaginationFetcher = async <\n  Options extends PostgrestClientOptions,\n  Schema extends GenericSchema,\n  Row extends Record<string, unknown>,\n  Result,\n  RelationName = unknown,\n  Relationships = unknown,\n>(\n  query: PostgrestTransformBuilder<\n    Options,\n    Schema,\n    Row,\n    Result[],\n    RelationName,\n    Relationships\n  >,\n  {\n    limit,\n    offset,\n    rpcArgs,\n  }: {\n    limit: number;\n    offset: number;\n    rpcArgs: { limit: string; offset: string };\n  },\n) => {\n  if (query['method'] === 'GET') {\n    query['url'].searchParams.set(rpcArgs.limit, String(limit));\n    query['url'].searchParams.set(rpcArgs.offset, String(offset));\n  } else {\n    query['body'] = {\n      ...(isPlainObject(query['body']) ? query['body'] : {}),\n      [rpcArgs.limit]: limit,\n      [rpcArgs.offset]: offset,\n    };\n  }\n\n  const { data } = await query.throwOnError();\n\n  // cannot be null because of .throwOnError()\n  return data as Result[];\n};\n\nexport const createOffsetPaginationHasMoreFetcher = <\n  Options extends PostgrestClientOptions,\n  Schema extends GenericSchema,\n  Row extends Record<string, unknown>,\n  Result,\n  Args,\n  RelationName = unknown,\n  Relationships = unknown,\n>(\n  queryFactory:\n    | (() => PostgrestTransformBuilder<\n        Options,\n        Schema,\n        Row,\n        Result[],\n        RelationName,\n        Relationships\n      >)\n    | null,\n  {\n    decode,\n    pageSize,\n    rpcArgs,\n  }: {\n    decode: PostgrestOffsetPaginationKeyDecoder<Args>;\n    pageSize: number;\n    rpcArgs?: { limit: string; offset: string };\n  },\n): PostgrestOffsetPaginationFetcher<\n  PostgrestHasMorePaginationResponse<Result>,\n  Args\n> | null => {\n  if (!queryFactory) return null;\n  return async (args) => {\n    const decodedKey = decode(args);\n    const limit = decodedKey.limit ? decodedKey.limit : pageSize;\n    const offset = decodedKey.offset ?? 0;\n    const query = queryFactory();\n    return rpcArgs\n      ? await rpcOffsetPaginationHasMoreFetcher<\n          Options,\n          Schema,\n          Row,\n          Result,\n          RelationName,\n          Relationships\n        >(query, {\n          limit,\n          offset,\n          pageSize,\n          rpcArgs,\n        })\n      : await offsetPaginationHasMoreFetcher<\n          Options,\n          Schema,\n          Row,\n          Result,\n          RelationName,\n          Relationships\n        >(query, {\n          limit,\n          offset,\n          pageSize,\n        });\n  };\n};\n\nexport const offsetPaginationHasMoreFetcher = async <\n  Options extends PostgrestClientOptions,\n  Schema extends GenericSchema,\n  Row extends Record<string, unknown>,\n  Result,\n  RelationName = unknown,\n  Relationships = unknown,\n>(\n  query: PostgrestTransformBuilder<\n    Options,\n    Schema,\n    Row,\n    Result[],\n    RelationName,\n    Relationships\n  >,\n  {\n    limit,\n    offset,\n    pageSize,\n  }: { limit: number; offset: number; pageSize: number },\n) => {\n  const { data } = await query.range(offset, offset + limit).throwOnError();\n\n  let hasMore = false;\n  if (data && data.length === pageSize + 1) {\n    hasMore = true;\n    data.pop();\n  }\n  return {\n    // cannot be null because of .throwOnError()\n    data: data as Result[],\n    hasMore,\n  };\n};\n\nexport const rpcOffsetPaginationHasMoreFetcher = async <\n  Options extends PostgrestClientOptions,\n  Schema extends GenericSchema,\n  Row extends Record<string, unknown>,\n  Result,\n  RelationName = unknown,\n  Relationships = unknown,\n>(\n  query: PostgrestTransformBuilder<\n    Options,\n    Schema,\n    Row,\n    Result[],\n    RelationName,\n    Relationships\n  >,\n  {\n    limit,\n    offset,\n    pageSize,\n    rpcArgs,\n  }: {\n    limit: number;\n    offset: number;\n    pageSize: number;\n    rpcArgs: { limit: string; offset: string };\n  },\n) => {\n  if (query['method'] === 'GET') {\n    query['url'].searchParams.set(rpcArgs.limit, String(limit + 1));\n    query['url'].searchParams.set(rpcArgs.offset, String(offset));\n  } else {\n    query['body'] = {\n      ...(isPlainObject(query['body']) ? query['body'] : {}),\n      [rpcArgs.limit]: limit + 1,\n      [rpcArgs.offset]: offset,\n    };\n  }\n\n  const { data } = await query.throwOnError();\n\n  let hasMore = false;\n  if (data && data.length === pageSize + 1) {\n    hasMore = true;\n    data.pop();\n  }\n  return {\n    // cannot be null because of .throwOnError()\n    data: data as Result[],\n    hasMore,\n  };\n};\n","import {\n  groupPathsRecursive,\n  isNestedPath,\n} from '../lib/group-paths-recursive';\nimport type { Path } from '../lib/query-types';\nimport { unflatten } from 'flat';\n\n/**\n * Denormalize a normalized response object using the paths of the target query\n **/\nexport const denormalize = <R extends Record<string, unknown>>(\n  // the paths into which we need to transform\n  paths: Path[],\n  // the normalized response data\n  obj: R,\n): R => {\n  const groups = groupPathsRecursive(paths);\n\n  if (groups.some((g) => g.path === '*')) {\n    // if a wildcard path is present, we expand the groups with all values from the object that are not part of a nested path from `paths`.\n    // This will include also unwanted values, e.g. from a join on another relation because its impossible for us to distinguish between json columns and joins.\n    Object.keys(obj).forEach((k) => {\n      const keyParts = k.split('.');\n      if (\n        keyParts.length > 1 &&\n        groups.some((g) => isNestedPath(g) && g.path === keyParts[0])\n      ) {\n        // skip if key is actually part of a nested path from the groups\n        return;\n      }\n      if (groups.some((g) => g.path === keyParts[0])) {\n        // skip if key is already part of the groups\n        return;\n      }\n\n      groups.push({\n        declaration: keyParts[0],\n        path: keyParts[0],\n      });\n    });\n  }\n\n  return groups.reduce<R>((prev, curr) => {\n    // skip the wildcard since we already handled it above\n    if (curr.path === '*') return prev;\n    let value = obj[curr.path];\n\n    if (!isNestedPath(curr)) {\n      if (typeof value === 'undefined') {\n        // if simple array, e.g. ['a', 'b', 'c'], unflatten\n        const array = Object.entries(obj).reduce<any[]>((prev, [k, v]) => {\n          // test if key is curr_path.0, curr_path.1 etc.\n          if (new RegExp(`^${curr.path}.\\\\d+$`).test(k)) {\n            prev.push(v);\n          }\n          return prev;\n        }, []);\n        if (array.length > 0) {\n          value = array;\n        }\n      }\n      if (typeof value === 'undefined') {\n        // if json(b) column, unflatten\n        let isArray = false;\n        const jsonValue = Object.entries(obj).reduce<Record<string, unknown>>(\n          (prev, [k, v]) => {\n            if (k.startsWith(`${curr.path}.`)) {\n              const key = k.slice(curr.path.length + 1);\n              const maybeIdx = key.match(/^\\b\\d+\\b/);\n              if (maybeIdx && isFlatNestedArray(prev)) {\n                isArray = true;\n                prev = {\n                  ...prev,\n                  [maybeIdx[0]]: {\n                    ...(prev[maybeIdx[0]] ? prev[maybeIdx[0]] : {}),\n                    [key.slice(maybeIdx[0].length + 1)]: v,\n                  },\n                };\n              } else {\n                prev[maybeIdx ? maybeIdx[0] : key] = v;\n              }\n            }\n            return prev;\n          },\n          {},\n        );\n        if (Object.keys(jsonValue).length > 0) {\n          if (isArray) {\n            value = Object.values(jsonValue).map((v) => unflatten(v));\n          } else {\n            value = unflatten(jsonValue);\n          }\n        }\n      }\n      if (typeof value === 'undefined') {\n        return prev;\n      }\n      return {\n        ...prev,\n        [curr.alias || curr.path]: value,\n      };\n    }\n\n    // if value is null or an empty array, the relation is not set and we can return the \"empty\" value\n    if (value === null || (Array.isArray(value) && value.length === 0)) {\n      return {\n        ...prev,\n        [curr.alias || curr.path]: value,\n      };\n    }\n\n    let isArray = false;\n    const flatNestedObjectOrArray = Object.entries(obj).reduce<\n      Record<string, Record<string, unknown>> | Record<string, unknown>\n    >((prev, [k, v]) => {\n      const isNested =\n        k.startsWith(`${curr.path}.`) ||\n        (k.includes('!') &&\n          k.startsWith(`${removeFirstAlias(curr.declaration)}.`));\n\n      if (!isNested) return prev;\n      // either set to key, or to idx.key\n      // is either path.key or path!hint.key\n      const flatKey = k.slice(\n        (k.includes('!') ? removeFirstAlias(curr.declaration) : curr.path)\n          .length + 1,\n      );\n      const maybeIdx = flatKey.match(/^\\b\\d+\\b/);\n      if (maybeIdx && isFlatNestedArray(prev)) {\n        isArray = true;\n        const key = flatKey.slice(maybeIdx[0].length + 1);\n        return {\n          ...prev,\n          [maybeIdx[0]]: {\n            ...(prev[maybeIdx[0]] ? prev[maybeIdx[0]] : {}),\n            [key]: v,\n          },\n        };\n      }\n      return {\n        ...prev,\n        [flatKey]: v,\n      };\n    }, {});\n\n    if (Object.keys(flatNestedObjectOrArray).length === 0) return prev;\n    if (isArray && isFlatNestedArray(flatNestedObjectOrArray)) {\n      return {\n        ...prev,\n        [curr.alias || curr.path]: Object.values(flatNestedObjectOrArray).map(\n          (v) => denormalize(curr.paths, v),\n        ),\n      };\n    }\n    return {\n      ...prev,\n      [curr.alias || curr.path]: denormalize(\n        curr.paths,\n        flatNestedObjectOrArray,\n      ),\n    };\n  }, {} as R);\n};\n\n// just to make ts happy\nconst isFlatNestedArray = (\n  obj: Record<string, Record<string, unknown>> | Record<string, unknown>,\n): obj is Record<string, Record<string, unknown>> => true;\n\nconst removeFirstAlias = (key: string): string => {\n  const split = key.split(':');\n  if (split.length === 1) return key;\n  split.shift();\n  return split.join(':');\n};\n","import {\n  type FilterDefinitions,\n  isAndFilter,\n  isFilterDefinition,\n  isOrFilter,\n} from './query-types';\n\nexport const filterFilterDefinitionsByPaths = (\n  f: FilterDefinitions,\n  paths: string[],\n) => {\n  return f.reduce<FilterDefinitions>((prev, filter) => {\n    if (isAndFilter(filter)) {\n      const filters = filterFilterDefinitionsByPaths(filter.and, paths);\n      if (filters.length > 0) {\n        prev.push({ and: filters });\n      }\n    } else if (isOrFilter(filter)) {\n      const filters = filterFilterDefinitionsByPaths(filter.or, paths);\n      if (filters.length > 0) {\n        prev.push({ or: filters });\n      }\n    } else if (isFilterDefinition(filter) && paths.includes(filter.path)) {\n      prev.push(filter);\n    }\n    return prev;\n  }, []);\n};\n","export const isObject = (v: unknown): v is Record<string, unknown> =>\n  typeof v === 'object' && !Array.isArray(v) && v !== null;\n","export type MaybeLikePostgrestBuilder<Result> = unknown;\n\nexport type LikePostgrestBuilder<Result> = {\n  url: URL;\n  method: 'GET' | 'HEAD' | 'POST' | 'PATCH' | 'DELETE';\n  headers: Headers;\n  schema?: string;\n  body?: unknown;\n};\n\nexport const isLikePostgrestBuilder = <Result>(\n  v: MaybeLikePostgrestBuilder<Result>,\n): v is LikePostgrestBuilder<Result> => {\n  if (typeof v !== 'object' || v === null) return false;\n  const obj = v as LikePostgrestBuilder<Result>;\n\n  return (\n    typeof obj['url'] === 'object' &&\n    typeof obj['headers'] === 'object' &&\n    typeof obj['method'] === 'string'\n  );\n};\n","import type { FilterOperator, OperatorFn } from './query-types';\nimport { deepEqual } from 'fast-equals';\n\n/**\n * Builds a regex for a (i)like postgres operator by replacing the \"%\" with a regex wildcard \".*\"\n * @param search The search value\n * @returns A RegExp representing the (i)like operation\n */\nconst buildLikeRegex = (search: string) =>\n  new RegExp(`^${search.replace(/%/g, '.*')}$`);\n\n/**\n * A poor humans attempt to implement postgres text search in javascript.\n * Converts the search string into a regex before testing it against all tokens.\n */\nconst textSearch: OperatorFn = (c, v) => {\n  const regExp = `^${v\n    .split('&')\n    .map((v: string) => v.trim().toLowerCase())\n    .join('|')\n    .replace(/:\\*/g, '.*')}$`;\n  const tokens = c\n    .match(/'(.*?)'/g)\n    .map((t: string) => t.replace(/'/g, '').toLowerCase());\n  return tokens.some((t: string) => new RegExp(regExp).test(t));\n};\n\n/**\n * Date instances do not work with equality operators, which is why their times are compared instead.\n *\n * ref: https://stackoverflow.com/questions/492994/compare-two-dates-with-javascript\n * @param v The input value\n * @returns If the input value is an instanceof Date, return v.getTime(), else the input value\n */\nconst ifDateGetTime = (v: any) => (v instanceof Date ? v.getTime() : v);\n\nconst enclose = (v: string, char: string) => {\n  if (!v.startsWith(char)) v = `${char}${v}`;\n  if (!v.endsWith(char)) v = `${v}${char}`;\n  return v;\n};\n\n/**\n * An object containing all FilterOperator implementations\n */\nexport const OPERATOR_MAP: { [Key in FilterOperator]?: OperatorFn } = {\n  eq: (c, v) => ifDateGetTime(c) === ifDateGetTime(v),\n  neq: (c, v) => ifDateGetTime(c) !== ifDateGetTime(v),\n  gt: (c, v) => c > v,\n  gte: (c, v) => c >= v,\n  lt: (c, v) => c < v,\n  lte: (c, v) => c <= v,\n  like: (c, v) => buildLikeRegex(v).test(c.toString()),\n  ilike: (c, v) =>\n    buildLikeRegex(v.toLowerCase()).test(c.toString().toLowerCase()),\n  is: (c, v) => c === v,\n  in: (c, v) => {\n    const parsedValue = v.slice(1, -1).split(',');\n    return parsedValue.some((i: string) => i === c);\n  },\n  // contains\n  cs: (c, v) => {\n    if (!Array.isArray(c)) return false;\n    if (!Array.isArray(v)) v = v.slice(1, -1).split(',');\n    return v.every((i: string) => c.some((colVal) => deepEqual(colVal, i)));\n  },\n  // containedBy\n  cd: (c, v) => {\n    if (!Array.isArray(c)) return false;\n    if (!Array.isArray(v)) v = v.slice(1, -1).split(',');\n    return c.every((i: string) =>\n      v.some((cmpVal: any) => deepEqual(cmpVal, i)),\n    );\n  },\n  // overlap\n  ov: (c, v) => {\n    if (!Array.isArray(c)) return false;\n    if (!Array.isArray(v)) v = v.slice(1, -1).split(',');\n    return c.some((colVal) =>\n      v.some((filterVal: any) => deepEqual(colVal, filterVal)),\n    );\n  },\n  fts: textSearch,\n  plfts: (c, v) =>\n    buildLikeRegex(enclose(v.toLowerCase(), '%')).test(\n      c.toString().toLowerCase(),\n    ),\n};\n","/**\n * Returns the index of the last element in the array where predicate is true, and -1\n * otherwise.\n * @param array The source array to search in\n * @param predicate find calls predicate once for each element of the array, in descending\n * order, until it finds one where predicate returns true. If such an element is found,\n * findLastIndex immediately returns that element index. Otherwise, findLastIndex returns -1.\n */\nexport function findLastIndex<T>(\n  array: T[],\n  predicate: (value: T, index: number, obj: T[]) => boolean,\n): number {\n  let l = array.length;\n  while (l--) {\n    if (predicate(array[l], l, array)) return l;\n  }\n  return -1;\n}\n","/**\n *\n * @param i Ahhh gotta love typescript\n * @returns\n */\nexport const isNotNull = <I>(i: I | null): i is I => i !== null;\n","import { findLastIndex } from './lib/find-last-index';\nimport { isNotNull } from './lib/is-not-null';\nimport { OPERATOR_MAP } from './lib/operators';\nimport { parseSelectParam } from './lib/parse-select-param';\nimport { parseValue } from './lib/parse-value';\nimport type {\n  FilterDefinition,\n  FilterDefinitions,\n  FilterOperator,\n  Path,\n} from './lib/query-types';\n\nexport const SUPPORTED_OPERATORS = ['or', ...Object.keys(OPERATOR_MAP)];\n\n/**\n * Splits a string on commas, but respects `{...}` and `(...)` delimiters.\n * This prevents array literals like `{a,b}` from being split incorrectly.\n */\nfunction splitOnComma(str: string): string[] {\n  const parts: string[] = [];\n  let current = '';\n  let braceDepth = 0;\n  let parenDepth = 0;\n  for (let i = 0; i < str.length; i++) {\n    const ch = str[i];\n    if (ch === '{') braceDepth++;\n    else if (ch === '}') braceDepth--;\n    else if (ch === '(') parenDepth++;\n    else if (ch === ')') parenDepth--;\n\n    if (ch === ',' && braceDepth === 0 && parenDepth === 0) {\n      parts.push(current);\n      current = '';\n    } else {\n      current += ch;\n    }\n  }\n  parts.push(current);\n  return parts;\n}\n\nexport type PostgrestQueryParserOptions = {\n  /**\n   * If defined, will use only filters that apply to the given paths\n   */\n  exclusivePaths?: string[];\n};\n\nexport class PostgrestQueryParser {\n  private readonly _params: URLSearchParams;\n\n  private _filters: FilterDefinitions | undefined;\n  private _paths: Path[] | undefined;\n\n  constructor(\n    query: string,\n    public readonly opts?: PostgrestQueryParserOptions,\n  ) {\n    this._params = new URLSearchParams(query);\n  }\n\n  /**\n   * Getter that returns the paths and their aliases that the query selects. Will do the computation only once.\n   *\n   * ```js\n   * const p = new PostgrestParser(\n   * supabaseClient.from(\"test\")\n   *    .select(\n   *      `name,\n   *       city:cities (\n   *        test:name\n   *      ),\n   *      countries (\n   *        capital,\n   *        population,\n   *        some_ref (\n   *          test:first,\n   *          second\n   *        )\n   *      )`\n   *    );\n   * console.log(p.paths);\n   * //  [\n   * //    { alias: undefined, path: \"name\" },\n   * //    { alias: \"city.test\", path: \"cities.name\" },\n   * //    { alias: undefined, path: \"countries.capital\" },\n   * //    { alias: undefined, path: \"countries.population\" },\n   * //    {\n   * //      alias: \"countries.some_ref.test\",\n   * //      path: \"countries.some_ref.first\",\n   * //    },\n   * //    { alias: undefined, path: \"countries.some_ref.second\" },\n   * //  ];\n   * ```\n   *\n   * @returns an array of paths that the query selects, containing the columns and aliases\n   */\n  get paths(): Path[] {\n    if (!this._paths) {\n      const select = this._params.get('select');\n      this._paths = select ? parseSelectParam(select) : [];\n    }\n    return this._paths;\n  }\n\n  /**\n   * Getter that returns the filters that this query applies in a json object.\n   *\n   * ```js\n   * const p = new PostgrestParser(\n   * supabaseClient.from(\"test\").select('*')\n   *  .or(\"full_name.eq.20,test.neq.true,and(full_name.eq.Test Name,email.eq.test@mail.com)\")\n   *  .eq(\"id\", \"123\")\n   *  .contains(\"id\", \"456\")\n   * );\n   *\n   * console.log(p.filters);\n   *\n   * // [\n   * //   {\n   * //     or: [\n   * //       {\n   * //         path: \"full_name\",\n   * //         negate: false,\n   * //         operator: \"eq\",\n   * //         value: 20,\n   * //       },\n   * //       {\n   * //         path: \"test\",\n   * //         negate: false,\n   * //         operator: \"neq\",\n   * //         value: true,\n   * //       },\n   * //       {\n   * //         and: [\n   * //           {\n   * //             path: \"full_name\",\n   * //             negate: false,\n   * //             operator: \"eq\",\n   * //             value: \"Test Name\",\n   * //           },\n   * //           {\n   * //             path: \"email\",\n   * //             negate: false,\n   * //             operator: \"eq\",\n   * //             value: \"test@mail.com\",\n   * //           },\n   * //         ],\n   * //       },\n   * //     ],\n   * //   },\n   * //   {\n   * //     path: \"id\",\n   * //     negate: false,\n   * //     operator: \"eq\",\n   * //     value: 123,\n   * //   },\n   * //   {\n   * //     path: \"id\",\n   * //     negate: false,\n   * //     operator: \"cs\",\n   * //     value: 456,\n   * //   },\n   * // ];\n   * ```\n   *\n   * @returns a FilterDefinitions object\n   */\n  get filters(): FilterDefinitions {\n    if (!this._filters) {\n      const filters: FilterDefinitions = [];\n      this._params.forEach((value, key) => {\n        if (\n          SUPPORTED_OPERATORS.some(\n            (f) => key === f || value.split('.').includes(f),\n          )\n        ) {\n          const filter = this.parseFilterString(`${key}.${value}`, undefined);\n          if (filter !== null) filters.push(filter);\n        }\n      });\n      this._filters = filters;\n    }\n    return this._filters;\n  }\n\n  private parseFilterString(\n    filter: string,\n    prefix?: string,\n  ):\n    | FilterDefinition\n    | { or: FilterDefinitions }\n    | { and: FilterDefinitions }\n    | null {\n    if (filter.startsWith('and(') && filter.endsWith(')')) {\n      // nested and\n      const andFilters = splitOnComma(filter.slice(4, -1))\n        .map((s) => this.parseFilterString(s, prefix))\n        .filter(isNotNull);\n      if (andFilters.length === 0) return null;\n      else return { and: andFilters };\n    }\n\n    const split = filter.split('.');\n\n    // or\n    if ([split[0], split[1]].includes('or')) {\n      let foreignTable: string | undefined;\n      if (split[1] === 'or') {\n        // with foreign table\n        foreignTable = split[0];\n      }\n\n      const orFilters = splitOnComma(\n        filter.slice(4 + (foreignTable ? foreignTable.length + 1 : 0), -1),\n      )\n        .map((s) => this.parseFilterString(s, foreignTable))\n        .filter(isNotNull);\n      if (orFilters.length === 0) return null;\n      else return { or: orFilters };\n    }\n\n    const operatorIdx = findLastIndex(split, (s) =>\n      SUPPORTED_OPERATORS.includes(s),\n    );\n    if (operatorIdx === -1)\n      throw new Error(\n        `Could not find a valid operator in ${split.join('.')}. Supported are ${SUPPORTED_OPERATORS.join(',')}.`,\n      );\n    const negate = split[operatorIdx - 1] === 'not';\n\n    const pathOrAlias = [\n      prefix,\n      ...split.slice(0, negate ? operatorIdx - 1 : operatorIdx),\n    ]\n      .filter(Boolean)\n      .join('.')\n      .replace(/\\s/g, '');\n\n    let path = pathOrAlias;\n    let alias;\n    // filter paths can use either the real path or the alias\n    // search for alias and path in paths of query\n    // if none is found, its a path because the alias would need to be defined\n    // in the query\n    for (const p of this.paths) {\n      if (p.path === pathOrAlias) {\n        alias = p.alias;\n        break;\n      }\n      if (p.alias === pathOrAlias) {\n        path = p.path;\n        alias = p.alias;\n        break;\n      }\n    }\n\n    if (\n      this.opts &&\n      Array.isArray(this.opts.exclusivePaths) &&\n      !this.opts.exclusivePaths.includes(path)\n    ) {\n      return null;\n    }\n\n    const operator = split[operatorIdx] as FilterOperator;\n    const value = split.slice(operatorIdx + 1).join('.');\n    return {\n      path,\n      alias,\n      negate,\n      operator,\n      value: parseValue(value),\n    };\n  }\n}\n","import { denormalize } from './filter/denormalize';\nimport { extractPathsFromFilters } from './lib/extract-paths-from-filter';\nimport { filterFilterDefinitionsByPaths } from './lib/filter-filter-definitions-by-paths';\nimport { get } from './lib/get';\nimport { isObject } from './lib/is-object';\nimport {\n  MaybeLikePostgrestBuilder,\n  isLikePostgrestBuilder,\n} from './lib/like-postgrest-builder';\nimport { OPERATOR_MAP } from './lib/operators';\nimport { parseValue } from './lib/parse-value';\nimport type {\n  FilterDefinition,\n  FilterDefinitions,\n  FilterFn,\n  OperatorFn,\n  Path,\n  ValueType,\n} from './lib/query-types';\nimport {\n  PostgrestQueryParser,\n  type PostgrestQueryParserOptions,\n} from './postgrest-query-parser';\n\nexport class PostgrestFilter<Result extends Record<string, unknown>> {\n  private _fn: FilterFn<Result> | undefined;\n  private _selectFn: FilterFn<Result> | undefined;\n  private _filtersFn: FilterFn<Result> | undefined;\n  private _filterPaths: Path[];\n  public hasWildcardPath: boolean | undefined;\n  public hasAggregatePath: boolean | undefined;\n\n  constructor(\n    public readonly params: { filters: FilterDefinitions; paths: Path[] },\n  ) {\n    this._filterPaths = extractPathsFromFilters(\n      this.params.filters,\n      this.params.paths,\n    );\n    this.hasWildcardPath = this.params.paths.some((p) =>\n      p.declaration.endsWith('*'),\n    );\n    this.hasAggregatePath = this.params.paths.some((p) => Boolean(p.aggregate));\n  }\n\n  public static fromQuery(query: string, opts?: PostgrestQueryParserOptions) {\n    const parser = new PostgrestQueryParser(query, opts);\n    return new PostgrestFilter({\n      filters: parser.filters,\n      paths: parser.paths,\n    });\n  }\n\n  public static fromBuilder<\n    Result extends Record<string, unknown> = Record<string, unknown>,\n  >(\n    fb: MaybeLikePostgrestBuilder<Result>,\n    opts?: PostgrestQueryParserOptions,\n  ): PostgrestFilter<Result> {\n    if (!isLikePostgrestBuilder(fb)) {\n      throw new Error('Invalid PostgrestBuilder');\n    }\n\n    const parser = new PostgrestQueryParser(\n      fb['url'].searchParams.toString(),\n      opts,\n    );\n    return new PostgrestFilter<Result>({\n      filters: parser.filters,\n      paths: parser.paths,\n    });\n  }\n\n  denormalize<Type extends Record<string, unknown>>(obj: Type): Type {\n    return denormalize([...this.params.paths, ...this._filterPaths], obj);\n  }\n\n  apply(obj: unknown): obj is Result {\n    if (!this._fn) {\n      this._fn = (obj): obj is Result =>\n        this.applyFilters(obj) && this.hasPaths(obj);\n    }\n    return this._fn(obj);\n  }\n\n  applyFilters(obj: unknown): obj is Result {\n    if (!this._filtersFn) {\n      const filterFns = this.params.filters.map((d) => this.buildFilterFn(d));\n      this._filtersFn = (obj): obj is Result =>\n        filterFns.every((fn) => isObject(obj) && fn(obj));\n    }\n    return this._filtersFn(obj);\n  }\n\n  hasFiltersOnPaths(paths: string[]): boolean {\n    return (\n      filterFilterDefinitionsByPaths(this.params.filters, paths).length > 0\n    );\n  }\n\n  applyFiltersOnPaths(obj: unknown, paths: string[]): obj is Result {\n    const filterFns = filterFilterDefinitionsByPaths(\n      this.params.filters,\n      paths,\n    ).map((d) => this.buildFilterFn(d));\n    const filtersFn = (obj: unknown): obj is Result =>\n      filterFns.every((fn) => isObject(obj) && fn(obj));\n    return filtersFn(obj);\n  }\n\n  hasPaths(obj: unknown): obj is Result {\n    if (!this._selectFn) {\n      this._selectFn = (obj): obj is Result =>\n        this.params.paths.every((p) =>\n          this.hasPathRecursive(obj, p.alias ?? p.path),\n        );\n    }\n    return this._selectFn(obj);\n  }\n\n  private hasPathRecursive(obj: unknown, path: string): boolean {\n    // obj is valid if v is null, because the foreign key relation can be null\n    if (obj === null) return true;\n\n    // normalise json operators \"->\" and \"->>\" to \".\"\n    const pathElements = path.replace(/->>|->/g, '.').split('.');\n\n    // we are at the deepest level\n    if (pathElements.length === 1) {\n      // else check if the path exists\n      return typeof get(obj, pathElements[0]) !== 'undefined';\n    }\n\n    // go deeper\n    const currentPathElement = pathElements.shift();\n    const v = get(obj, currentPathElement!);\n\n    // undefined means the path does not exist\n    if (typeof v === 'undefined') return false;\n\n    // if we have an array, check if all elements have the path\n    if (Array.isArray(v)) {\n      return v.every((i) => this.hasPathRecursive(i, pathElements.join('.')));\n    }\n\n    // if we dont have an array, continue recursively\n    return this.hasPathRecursive(v, pathElements.join('.'));\n  }\n\n  private applyFilterFn(\n    obj: object | any[],\n    path: string,\n    {\n      filterFn,\n      value,\n      negate,\n    }: { filterFn: OperatorFn; value: ValueType; negate: boolean },\n  ): boolean {\n    // parse json operators \"->\" and \"->>\" to \".\"\n    const pathElements = path.replace(/->>|->/g, '.').split('.');\n\n    const v = get(obj, pathElements[0]);\n\n    if (typeof v === 'undefined') {\n      // if obj is an array, we should apply the filter to all elements of the array\n      if (Array.isArray(obj)) {\n        return obj.every((o) =>\n          this.applyFilterFn(o, path, { filterFn, value, negate }),\n        );\n      }\n      return false;\n    }\n\n    if (pathElements.length > 1) {\n      // recursively resolve json path\n      return this.applyFilterFn(\n        v as Record<string, unknown>,\n        pathElements.slice(1).join('.'),\n        {\n          filterFn,\n          value,\n          negate,\n        },\n      );\n    }\n\n    const res = filterFn(parseValue(v), value);\n    if (negate) return !res;\n    return res;\n  }\n\n  private buildFilterFn(\n    def:\n      | FilterDefinition\n      | { or: FilterDefinitions }\n      | { and: FilterDefinitions },\n  ): (obj: object) => boolean {\n    if ('or' in def) {\n      return (obj: object) => def.or.some((d) => this.buildFilterFn(d)(obj));\n    }\n    if ('and' in def) {\n      return (obj: object) => def.and.every((d) => this.buildFilterFn(d)(obj));\n    }\n    const { operator, path, value, negate, alias } = def;\n    const filterFn = OPERATOR_MAP[operator];\n    if (!filterFn)\n      throw new Error(\n        `Unable to build filter function for ${JSON.stringify(\n          def,\n        )}. Operator ${operator} is not supported.`,\n      );\n\n    return (obj: object) =>\n      this.applyFilterFn(obj, alias ?? path, { filterFn, value, negate });\n  }\n}\n","import { encodeObject } from './lib/encode-object';\nimport { getTableFromUrl } from './lib/get-table-from-url';\nimport { isObject } from './lib/is-object';\nimport {\n  MaybeLikePostgrestBuilder,\n  isLikePostgrestBuilder,\n} from './lib/like-postgrest-builder';\nimport { parseOrderBy } from './lib/parse-order-by';\nimport type { OrderDefinition } from './lib/query-types';\nimport { sortSearchParams } from './lib/sort-search-param';\nimport {\n  PostgrestQueryParser,\n  type PostgrestQueryParserOptions,\n} from './postgrest-query-parser';\n\nexport class PostgrestParser<Result> extends PostgrestQueryParser {\n  private readonly _url: URL;\n  private readonly _headers: Headers;\n  private readonly _body: object | undefined;\n  private readonly _method: 'GET' | 'HEAD' | 'POST' | 'PATCH' | 'DELETE';\n\n  public readonly queryKey: string;\n  public readonly bodyKey: string | undefined;\n  public readonly count: string | null;\n  public readonly schema: string;\n  public readonly table: string;\n  public readonly isHead: boolean | undefined;\n  public readonly limit: number | undefined;\n  public readonly offset: number | undefined;\n  public readonly orderBy: OrderDefinition[] = [];\n  public readonly orderByKey: string;\n\n  constructor(\n    fb: MaybeLikePostgrestBuilder<Result>,\n    public readonly opts?: PostgrestQueryParserOptions,\n  ) {\n    if (!isLikePostgrestBuilder(fb)) {\n      throw new Error('Invalid PostgrestBuilder');\n    }\n\n    super(new URL(fb['url']).searchParams.toString(), opts);\n\n    this._url = new URL(fb['url']);\n    this._headers = fb['headers'];\n    this._body = isObject(fb['body']) ? { ...fb['body'] } : undefined;\n    this._method = fb['method'];\n\n    this.queryKey = sortSearchParams(this._url.searchParams).toString();\n\n    this.table = getTableFromUrl(this._url.toString());\n\n    if (this._body) {\n      this.bodyKey = encodeObject(this._body as Record<string, unknown>);\n    }\n\n    // 'Prefer': return=minimal|representation,count=exact|planned|estimated\n    const preferHeaders: Record<string, string> = (\n      this._headers.get('Prefer') || ''\n    )\n      .split(',')\n      .reduce<Record<string, string>>((prev, curr) => {\n        const s = curr.split('=');\n        return {\n          ...prev,\n          [s[0]]: s[1],\n        };\n      }, {});\n    this.count = preferHeaders['count'] ?? null;\n\n    this.schema = fb['schema'] as string;\n\n    this.isHead = this._method === 'HEAD';\n\n    const limit = this._url.searchParams.get('limit');\n    this.limit = limit ? Number(limit) : undefined;\n    const offset = this._url.searchParams.get('offset');\n    this.offset = offset ? Number(offset) : undefined;\n\n    this.orderBy = parseOrderBy(this._url.searchParams);\n    this.orderByKey = this.orderBy\n      .map(\n        ({ column, ascending, nullsFirst, foreignTable }) =>\n          `${foreignTable ? `${foreignTable}.` : ''}${column}:${\n            ascending ? 'asc' : 'desc'\n          }.${nullsFirst ? 'nullsFirst' : 'nullsLast'}`,\n      )\n      .join('|');\n  }\n}\n","import {\n  type MutationFetcherResponse,\n  buildMutationFetcherResponse,\n} from './fetch/build-mutation-fetcher-response';\nimport {\n  type BuildNormalizedQueryOps,\n  buildNormalizedQuery,\n} from './fetch/build-normalized-query';\nimport { GenericSchema, GenericTable } from './lib/postgrest-types';\nimport type {\n  PostgrestClientOptions,\n  PostgrestQueryBuilder,\n} from '@supabase/postgrest-js';\nimport { UnstableGetResult as GetResult } from '@supabase/postgrest-js';\n\nexport type UpdateFetcher<T extends GenericTable, R> = (\n  input: Partial<T['Row']>,\n) => Promise<MutationFetcherResponse<R> | null>;\n\nexport type UpdateFetcherOptions<\n  O extends PostgrestClientOptions,\n  S extends GenericSchema,\n  T extends GenericTable,\n  Re = T extends { Relationships: infer R } ? R : unknown,\n> = Parameters<PostgrestQueryBuilder<O, S, T, Re>['update']>[1] & {\n  stripPrimaryKeys?: boolean;\n};\n\nexport const buildUpdateFetcher =\n  <\n    O extends PostgrestClientOptions,\n    S extends GenericSchema,\n    T extends GenericTable,\n    RelationName,\n    Re = T extends { Relationships: infer R } ? R : unknown,\n    Q extends string = '*',\n    R = GetResult<S, T['Row'], RelationName, Re, Q extends '*' ? '*' : Q, O>,\n  >(\n    qb: PostgrestQueryBuilder<O, S, T, Re>,\n    primaryKeys: (keyof T['Row'])[],\n    {\n      stripPrimaryKeys = true,\n      ...opts\n    }: BuildNormalizedQueryOps<Q> & UpdateFetcherOptions<O, S, T>,\n  ): UpdateFetcher<T, R> =>\n  async (\n    input: Partial<T['Row']>,\n  ): Promise<MutationFetcherResponse<R> | null> => {\n    const payload = stripPrimaryKeys\n      ? primaryKeys.reduce<typeof input>(\n          (acc, key) => {\n            delete acc[key];\n            return acc;\n          },\n          { ...input },\n        )\n      : input;\n    let filterBuilder = qb.update(payload as any, opts); // todo fix type;\n    for (const key of primaryKeys) {\n      const value = input[key];\n      // The value can be 0 or false, so we need to check if it's null or undefined instead of falsy\n      if (value === null || value === undefined)\n        throw new Error(`Missing value for primary key ${String(key)}`);\n      // todo fix type\n      filterBuilder = filterBuilder.eq(key as string, value as any);\n    }\n\n    const query = buildNormalizedQuery<Q>(opts);\n    if (query) {\n      const { selectQuery, groupedUserQueryPaths, groupedPaths } = query;\n      const { data } = await filterBuilder\n        .select(selectQuery)\n        .throwOnError()\n        .single();\n      return buildMutationFetcherResponse(data as R, {\n        groupedPaths,\n        groupedUserQueryPaths,\n      });\n    }\n    await filterBuilder.throwOnError().single();\n    return { normalizedData: input as R };\n  };\n","import {\n  type MutationFetcherResponse,\n  buildMutationFetcherResponse,\n} from './fetch/build-mutation-fetcher-response';\nimport {\n  type BuildNormalizedQueryOps,\n  buildNormalizedQuery,\n} from './fetch/build-normalized-query';\nimport { GenericSchema, GenericTable } from './lib/postgrest-types';\nimport type {\n  PostgrestClientOptions,\n  PostgrestQueryBuilder,\n} from '@supabase/postgrest-js';\nimport { UnstableGetResult as GetResult } from '@supabase/postgrest-js';\n\nexport type UpsertFetcher<T extends GenericTable, R> = (\n  input: T['Insert'][],\n) => Promise<MutationFetcherResponse<R>[] | null>;\n\nexport type UpsertFetcherOptions<\n  O extends PostgrestClientOptions,\n  S extends GenericSchema,\n  T extends GenericTable,\n  Re = T extends { Relationships: infer R } ? R : unknown,\n> = Parameters<PostgrestQueryBuilder<O, S, T, Re>['upsert']>[1];\n\nexport const buildUpsertFetcher =\n  <\n    O extends PostgrestClientOptions,\n    S extends GenericSchema,\n    T extends GenericTable,\n    RelationName,\n    Re = T extends { Relationships: infer R } ? R : unknown,\n    Q extends string = '*',\n    R = GetResult<S, T['Row'], RelationName, Re, Q extends '*' ? '*' : Q, O>,\n  >(\n    qb: PostgrestQueryBuilder<O, S, T, Re>,\n    opts: BuildNormalizedQueryOps<Q> & UpsertFetcherOptions<O, S, T>,\n  ): UpsertFetcher<T, R> =>\n  async (\n    input: T['Insert'][],\n  ): Promise<MutationFetcherResponse<R>[] | null> => {\n    const query = buildNormalizedQuery<Q>(opts);\n    if (query) {\n      const { selectQuery, groupedUserQueryPaths, groupedPaths } = query;\n      const { data } = await qb\n        .upsert(input as any, opts) // todo fix type\n        .throwOnError()\n        .select(selectQuery);\n      return (data as R[]).map((d) =>\n        buildMutationFetcherResponse(d, {\n          groupedPaths,\n          groupedUserQueryPaths,\n        }),\n      );\n    }\n    await qb\n      .upsert(input as any) // todo fix type\n      .throwOnError();\n    return input.map((d) => ({\n      normalizedData: d as R,\n    }));\n  };\n","import {\n  isPostgrestHasMorePaginationCacheData,\n  isPostgrestPaginationCacheData,\n} from './lib/cache-data-types';\nimport { findIndexOrdered } from './lib/find-index-ordered';\nimport { parseOrderByKey } from './lib/parse-order-by-key';\nimport type { OrderDefinition } from './lib/query-types';\nimport { isAnyPostgrestResponse } from './lib/response-types';\nimport { shouldRevalidateRelation } from './mutate/should-revalidate-relation';\nimport { shouldRevalidateTable } from './mutate/should-revalidate-table';\nimport {\n  toHasMorePaginationCacheData,\n  toPaginationCacheData,\n} from './mutate/transformers';\nimport type { DecodedKey, MutatorFn, RevalidateOpts } from './mutate/types';\nimport type { PostgrestFilter } from './postgrest-filter';\nimport type { PostgrestQueryParserOptions } from './postgrest-query-parser';\nimport { merge as mergeAnything } from 'merge-anything';\n\ntype MergeFn<Type extends Record<string, unknown>> = (\n  current: Type,\n  input: Type,\n) => Type;\n\nexport const upsert = <Type extends Record<string, unknown>>(\n  input: Type,\n  currentData: Type[],\n  primaryKeys: (keyof Type)[],\n  filter: Pick<PostgrestFilter<Type>, 'apply'>,\n  mergeFn?: MergeFn<Type>,\n  orderBy?: OrderDefinition[],\n) => {\n  const merge = mergeFn ?? (mergeAnything as MergeFn<Type>);\n\n  // find item\n  const itemIdx = currentData.findIndex((oldItem) =>\n    primaryKeys.every((pk) => oldItem[pk] === input[pk]),\n  );\n\n  let newItem = input;\n  let newItemIdx = itemIdx;\n\n  if (itemIdx !== -1) {\n    // if exists, merge and remove\n    newItem = merge(currentData[itemIdx], input) as Type;\n    currentData.splice(itemIdx, 1);\n  }\n\n  if (orderBy && Array.isArray(orderBy) && orderBy.length > 0) {\n    // if ordered, find new idx\n    newItemIdx = findIndexOrdered(newItem, currentData, orderBy);\n  }\n\n  if (newItemIdx === -1) {\n    // default to prepend\n    newItemIdx = 0;\n  }\n\n  // check that new item is still a valid member of the list and has all required paths\n  if (filter.apply(newItem)) {\n    currentData.splice(newItemIdx, 0, newItem);\n  }\n\n  return currentData;\n};\n\nexport type UpsertItemOperation<Type extends Record<string, unknown>> = {\n  table: string;\n  schema: string;\n  input: Type;\n  primaryKeys: (keyof Type)[];\n  merge?: (current: Type, input: Type) => Type;\n} & RevalidateOpts<Type>;\n\nexport type UpsertItemCache<KeyType, Type extends Record<string, unknown>> = {\n  /**\n   * The keys currently present in the cache\n   */\n  cacheKeys: KeyType[];\n  /**\n   * Should return a PostgrestFilter for the given query.\n   * This is exposed as a function so results can be cached by the cache library.\n   */\n  getPostgrestFilter: (\n    query: string,\n    opts?: PostgrestQueryParserOptions,\n  ) => Pick<\n    PostgrestFilter<Type>,\n    | 'applyFilters'\n    | 'denormalize'\n    | 'hasFiltersOnPaths'\n    | 'applyFiltersOnPaths'\n    | 'apply'\n    | 'hasWildcardPath'\n    | 'hasAggregatePath'\n  >;\n  /**\n   * Decode a key. Should return null if not a PostgREST key.\n   */\n  decode: (k: KeyType) => DecodedKey | null;\n  /**\n   * The mutation function from the cache library\n   */\n  mutate: (key: KeyType, fn: MutatorFn<Type>) => Promise<void> | void;\n  /**\n   * The revalidation function from the cache library\n   */\n  revalidate: (key: KeyType) => Promise<void> | void;\n};\nexport const upsertItem = async <KeyType, Type extends Record<string, unknown>>(\n  op: UpsertItemOperation<Type>,\n  cache: UpsertItemCache<KeyType, Type>,\n) => {\n  const {\n    revalidateRelations: revalidateRelationsOpt,\n    revalidateTables: revalidateTablesOpt,\n    schema,\n    table,\n    primaryKeys,\n  } = op;\n  const { cacheKeys, decode, getPostgrestFilter, mutate, revalidate } = cache;\n\n  const mutations = [];\n  for (const k of cacheKeys) {\n    const key = decode(k);\n\n    // Exit early if not a postgrest key\n    if (!key) continue;\n    const filter = getPostgrestFilter(key.queryKey);\n    if (key.schema === schema && key.table === table) {\n      // parse input into expected target format\n      const transformedInput = filter.denormalize(op.input);\n      if (\n        filter.applyFilters(transformedInput) ||\n        // also allow upsert if either the filter does not apply eq filters on any pk\n        !filter.hasFiltersOnPaths(op.primaryKeys as string[]) ||\n        // or input matches all pk filters\n        filter.applyFiltersOnPaths(transformedInput, op.primaryKeys as string[])\n      ) {\n        const merge = op.merge ?? (mergeAnything as MergeFn<Type>);\n        const limit = key.limit ?? 1000;\n        const orderBy = key.orderByKey\n          ? parseOrderByKey(key.orderByKey)\n          : undefined;\n\n        if (\n          key.isHead === true ||\n          filter.hasWildcardPath ||\n          filter.hasAggregatePath\n        ) {\n          // we cannot know whether the new item after merging still has all paths required for a query if it contains a wildcard,\n          // because we do not know what columns a table has. we must always revalidate then.\n          mutations.push(revalidate(k));\n        } else {\n          mutations.push(\n            mutate(k, (currentData) => {\n              // Return early if undefined or null\n              if (!currentData) return currentData;\n\n              if (isPostgrestHasMorePaginationCacheData<Type>(currentData)) {\n                return toHasMorePaginationCacheData(\n                  upsert<Type>(\n                    transformedInput,\n                    currentData.flatMap((p) => p.data),\n                    primaryKeys,\n                    filter,\n                    merge,\n                    orderBy,\n                  ),\n                  currentData,\n                  limit,\n                );\n              } else if (isPostgrestPaginationCacheData<Type>(currentData)) {\n                return toPaginationCacheData(\n                  upsert<Type>(\n                    transformedInput,\n                    currentData.flat(),\n                    primaryKeys,\n                    filter,\n                    merge,\n                    orderBy,\n                  ),\n                  limit,\n                );\n              } else if (isAnyPostgrestResponse<Type>(currentData)) {\n                const { data } = currentData;\n\n                if (!Array.isArray(data)) {\n                  if (data === null) {\n                    return {\n                      data,\n                      count: currentData.count,\n                    };\n                  }\n                  const newData = merge(data, transformedInput);\n                  return {\n                    // Check if the new data is still valid given the key\n                    data: filter.apply(newData) ? newData : null,\n                    count: currentData.count,\n                  };\n                }\n\n                const newData = upsert<Type>(\n                  transformedInput,\n                  // deep copy data to avoid mutating the original\n                  JSON.parse(JSON.stringify(data)),\n                  primaryKeys,\n                  filter,\n                  merge,\n                  orderBy,\n                );\n\n                return {\n                  data: newData,\n                  count: newData.length,\n                };\n              }\n              return currentData;\n            }),\n          );\n        }\n      }\n    }\n\n    if (\n      revalidateTablesOpt &&\n      shouldRevalidateTable(revalidateTablesOpt, { decodedKey: key })\n    ) {\n      mutations.push(revalidate(k));\n    }\n\n    if (\n      revalidateRelationsOpt &&\n      shouldRevalidateRelation(revalidateRelationsOpt, {\n        input: op.input,\n        getPostgrestFilter,\n        decodedKey: key,\n      })\n    ) {\n      mutations.push(revalidate(k));\n    }\n  }\n  await Promise.all(mutations);\n};\n","import {\n  RevalidateTables,\n  shouldRevalidateTable,\n} from './mutate/should-revalidate-table';\nimport type { DecodedKey } from './mutate/types';\n\nexport type RevalidateTablesOperation = RevalidateTables;\n\nexport type RevalidateTablesCache<KeyType> = {\n  /**\n   * The keys currently present in the cache\n   */\n  cacheKeys: KeyType[];\n  /**\n   * Decode a key. Should return null if not a PostgREST key.\n   */\n  decode: (k: KeyType) => DecodedKey | null;\n  /**\n   * The revalidation function from the cache library\n   */\n  revalidate: (key: KeyType) => Promise<void> | void;\n};\n\nexport const revalidateTables = async <KeyType>(\n  tables: RevalidateTablesOperation,\n  cache: RevalidateTablesCache<KeyType>,\n) => {\n  const { cacheKeys, decode, revalidate } = cache;\n\n  const mutations = [];\n  for (const k of cacheKeys) {\n    const key = decode(k);\n\n    // Exit early if not a postgrest key\n    if (!key) continue;\n\n    if (shouldRevalidateTable(tables, { decodedKey: key })) {\n      mutations.push(revalidate(k));\n    }\n  }\n\n  await Promise.all(mutations);\n};\n"],"mappings":"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","names":["p","XRegExp","import_flat","data","newData","import_flat","prev","isArray","v","ifDateGetTime","obj","mergeAnything","newData"]}