@fragno-dev/workflows 0.0.1

package/dist/node/node_modules/.pnpm/drizzle-orm@0.44.7_@electric-sql_pglite@0.3.15_@libsql_client@0.14.0_@prisma_client@6.1_945233f0b9a56e69a65134d4c5811e1b/node_modules/drizzle-orm/pg-core/query-builders/select.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"select.js","names":[],"sources":["../../../../../../../../../../../node_modules/.pnpm/drizzle-orm@0.44.7_@electric-sql+pglite@0.3.15_@libsql+client@0.14.0_@prisma+client@6.1_945233f0b9a56e69a65134d4c5811e1b/node_modules/drizzle-orm/pg-core/query-builders/select.js"],"sourcesContent":["import { entityKind, is } from \"../../entity.js\";\nimport { PgViewBase } from \"../view-base.js\";\nimport { TypedQueryBuilder } from \"../../query-builders/query-builder.js\";\nimport { QueryPromise } from \"../../query-promise.js\";\nimport { SelectionProxyHandler } from \"../../selection-proxy.js\";\nimport { SQL, View } from \"../../sql/sql.js\";\nimport { Subquery } from \"../../subquery.js\";\nimport { Table } from \"../../table.js\";\nimport { tracer } from \"../../tracing.js\";\nimport {\n  applyMixins,\n  getTableColumns,\n  getTableLikeName,\n  haveSameKeys\n} from \"../../utils.js\";\nimport { orderSelectedFields } from \"../../utils.js\";\nimport { ViewBaseConfig } from \"../../view-common.js\";\nimport { extractUsedTable } from \"../utils.js\";\nclass PgSelectBuilder {\n  static [entityKind] = \"PgSelectBuilder\";\n  fields;\n  session;\n  dialect;\n  withList = [];\n  distinct;\n  constructor(config) {\n    this.fields = config.fields;\n    this.session = config.session;\n    this.dialect = config.dialect;\n    if (config.withList) {\n      this.withList = config.withList;\n    }\n    this.distinct = config.distinct;\n  }\n  authToken;\n  /** @internal */\n  setToken(token) {\n    this.authToken = token;\n    return this;\n  }\n  /**\n   * Specify the table, subquery, or other target that you're\n   * building a select query against.\n   *\n   * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-FROM | Postgres from documentation}\n   */\n  from(source) {\n    const isPartialSelect = !!this.fields;\n    const src = source;\n    let fields;\n    if (this.fields) {\n      fields = this.fields;\n    } else if (is(src, Subquery)) {\n      fields = Object.fromEntries(\n        Object.keys(src._.selectedFields).map((key) => [key, src[key]])\n      );\n    } else if (is(src, PgViewBase)) {\n      fields = src[ViewBaseConfig].selectedFields;\n    } else if (is(src, SQL)) {\n      fields = {};\n    } else {\n      fields = getTableColumns(src);\n    }\n    return new PgSelectBase({\n      table: src,\n      fields,\n      isPartialSelect,\n      session: this.session,\n      dialect: this.dialect,\n      withList: this.withList,\n      distinct: this.distinct\n    }).setToken(this.authToken);\n  }\n}\nclass PgSelectQueryBuilderBase extends TypedQueryBuilder {\n  static [entityKind] = \"PgSelectQueryBuilder\";\n  _;\n  config;\n  joinsNotNullableMap;\n  tableName;\n  isPartialSelect;\n  session;\n  dialect;\n  cacheConfig = void 0;\n  usedTables = /* @__PURE__ */ new Set();\n  constructor({ table, fields, isPartialSelect, session, dialect, withList, distinct }) {\n    super();\n    this.config = {\n      withList,\n      table,\n      fields: { ...fields },\n      distinct,\n      setOperators: []\n    };\n    this.isPartialSelect = isPartialSelect;\n    this.session = session;\n    this.dialect = dialect;\n    this._ = {\n      selectedFields: fields,\n      config: this.config\n    };\n    this.tableName = getTableLikeName(table);\n    this.joinsNotNullableMap = typeof this.tableName === \"string\" ? { [this.tableName]: true } : {};\n    for (const item of extractUsedTable(table)) this.usedTables.add(item);\n  }\n  /** @internal */\n  getUsedTables() {\n    return [...this.usedTables];\n  }\n  createJoin(joinType, lateral) {\n    return (table, on) => {\n      const baseTableName = this.tableName;\n      const tableName = getTableLikeName(table);\n      for (const item of extractUsedTable(table)) this.usedTables.add(item);\n      if (typeof tableName === \"string\" && this.config.joins?.some((join) => join.alias === tableName)) {\n        throw new Error(`Alias \"${tableName}\" is already used in this query`);\n      }\n      if (!this.isPartialSelect) {\n        if (Object.keys(this.joinsNotNullableMap).length === 1 && typeof baseTableName === \"string\") {\n          this.config.fields = {\n            [baseTableName]: this.config.fields\n          };\n        }\n        if (typeof tableName === \"string\" && !is(table, SQL)) {\n          const selection = is(table, Subquery) ? table._.selectedFields : is(table, View) ? table[ViewBaseConfig].selectedFields : table[Table.Symbol.Columns];\n          this.config.fields[tableName] = selection;\n        }\n      }\n      if (typeof on === \"function\") {\n        on = on(\n          new Proxy(\n            this.config.fields,\n            new SelectionProxyHandler({ sqlAliasedBehavior: \"sql\", sqlBehavior: \"sql\" })\n          )\n        );\n      }\n      if (!this.config.joins) {\n        this.config.joins = [];\n      }\n      this.config.joins.push({ on, table, joinType, alias: tableName, lateral });\n      if (typeof tableName === \"string\") {\n        switch (joinType) {\n          case \"left\": {\n            this.joinsNotNullableMap[tableName] = false;\n            break;\n          }\n          case \"right\": {\n            this.joinsNotNullableMap = Object.fromEntries(\n              Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false])\n            );\n            this.joinsNotNullableMap[tableName] = true;\n            break;\n          }\n          case \"cross\":\n          case \"inner\": {\n            this.joinsNotNullableMap[tableName] = true;\n            break;\n          }\n          case \"full\": {\n            this.joinsNotNullableMap = Object.fromEntries(\n              Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false])\n            );\n            this.joinsNotNullableMap[tableName] = false;\n            break;\n          }\n        }\n      }\n      return this;\n    };\n  }\n  /**\n   * Executes a `left join` operation by adding another table to the current query.\n   *\n   * Calling this method associates each row of the table with the corresponding row from the joined table, if a match is found. If no matching row exists, it sets all columns of the joined table to null.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/joins#left-join}\n   *\n   * @param table the table to join.\n   * @param on the `on` clause.\n   *\n   * @example\n   *\n   * ```ts\n   * // Select all users and their pets\n   * const usersWithPets: { user: User; pets: Pet | null; }[] = await db.select()\n   *   .from(users)\n   *   .leftJoin(pets, eq(users.id, pets.ownerId))\n   *\n   * // Select userId and petId\n   * const usersIdsAndPetIds: { userId: number; petId: number | null; }[] = await db.select({\n   *   userId: users.id,\n   *   petId: pets.id,\n   * })\n   *   .from(users)\n   *   .leftJoin(pets, eq(users.id, pets.ownerId))\n   * ```\n   */\n  leftJoin = this.createJoin(\"left\", false);\n  /**\n   * Executes a `left join lateral` operation by adding subquery to the current query.\n   *\n   * A `lateral` join allows the right-hand expression to refer to columns from the left-hand side.\n   *\n   * Calling this method associates each row of the table with the corresponding row from the joined table, if a match is found. If no matching row exists, it sets all columns of the joined table to null.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/joins#left-join-lateral}\n   *\n   * @param table the subquery to join.\n   * @param on the `on` clause.\n   */\n  leftJoinLateral = this.createJoin(\"left\", true);\n  /**\n   * Executes a `right join` operation by adding another table to the current query.\n   *\n   * Calling this method associates each row of the joined table with the corresponding row from the main table, if a match is found. If no matching row exists, it sets all columns of the main table to null.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/joins#right-join}\n   *\n   * @param table the table to join.\n   * @param on the `on` clause.\n   *\n   * @example\n   *\n   * ```ts\n   * // Select all users and their pets\n   * const usersWithPets: { user: User | null; pets: Pet; }[] = await db.select()\n   *   .from(users)\n   *   .rightJoin(pets, eq(users.id, pets.ownerId))\n   *\n   * // Select userId and petId\n   * const usersIdsAndPetIds: { userId: number | null; petId: number; }[] = await db.select({\n   *   userId: users.id,\n   *   petId: pets.id,\n   * })\n   *   .from(users)\n   *   .rightJoin(pets, eq(users.id, pets.ownerId))\n   * ```\n   */\n  rightJoin = this.createJoin(\"right\", false);\n  /**\n   * Executes an `inner join` operation, creating a new table by combining rows from two tables that have matching values.\n   *\n   * Calling this method retrieves rows that have corresponding entries in both joined tables. Rows without matching entries in either table are excluded, resulting in a table that includes only matching pairs.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/joins#inner-join}\n   *\n   * @param table the table to join.\n   * @param on the `on` clause.\n   *\n   * @example\n   *\n   * ```ts\n   * // Select all users and their pets\n   * const usersWithPets: { user: User; pets: Pet; }[] = await db.select()\n   *   .from(users)\n   *   .innerJoin(pets, eq(users.id, pets.ownerId))\n   *\n   * // Select userId and petId\n   * const usersIdsAndPetIds: { userId: number; petId: number; }[] = await db.select({\n   *   userId: users.id,\n   *   petId: pets.id,\n   * })\n   *   .from(users)\n   *   .innerJoin(pets, eq(users.id, pets.ownerId))\n   * ```\n   */\n  innerJoin = this.createJoin(\"inner\", false);\n  /**\n   * Executes an `inner join lateral` operation, creating a new table by combining rows from two queries that have matching values.\n   *\n   * A `lateral` join allows the right-hand expression to refer to columns from the left-hand side.\n   *\n   * Calling this method retrieves rows that have corresponding entries in both joined tables. Rows without matching entries in either table are excluded, resulting in a table that includes only matching pairs.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/joins#inner-join-lateral}\n   *\n   * @param table the subquery to join.\n   * @param on the `on` clause.\n   */\n  innerJoinLateral = this.createJoin(\"inner\", true);\n  /**\n   * Executes a `full join` operation by combining rows from two tables into a new table.\n   *\n   * Calling this method retrieves all rows from both main and joined tables, merging rows with matching values and filling in `null` for non-matching columns.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/joins#full-join}\n   *\n   * @param table the table to join.\n   * @param on the `on` clause.\n   *\n   * @example\n   *\n   * ```ts\n   * // Select all users and their pets\n   * const usersWithPets: { user: User | null; pets: Pet | null; }[] = await db.select()\n   *   .from(users)\n   *   .fullJoin(pets, eq(users.id, pets.ownerId))\n   *\n   * // Select userId and petId\n   * const usersIdsAndPetIds: { userId: number | null; petId: number | null; }[] = await db.select({\n   *   userId: users.id,\n   *   petId: pets.id,\n   * })\n   *   .from(users)\n   *   .fullJoin(pets, eq(users.id, pets.ownerId))\n   * ```\n   */\n  fullJoin = this.createJoin(\"full\", false);\n  /**\n   * Executes a `cross join` operation by combining rows from two tables into a new table.\n   *\n   * Calling this method retrieves all rows from both main and joined tables, merging all rows from each table.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/joins#cross-join}\n   *\n   * @param table the table to join.\n   *\n   * @example\n   *\n   * ```ts\n   * // Select all users, each user with every pet\n   * const usersWithPets: { user: User; pets: Pet; }[] = await db.select()\n   *   .from(users)\n   *   .crossJoin(pets)\n   *\n   * // Select userId and petId\n   * const usersIdsAndPetIds: { userId: number; petId: number; }[] = await db.select({\n   *   userId: users.id,\n   *   petId: pets.id,\n   * })\n   *   .from(users)\n   *   .crossJoin(pets)\n   * ```\n   */\n  crossJoin = this.createJoin(\"cross\", false);\n  /**\n   * Executes a `cross join lateral` operation by combining rows from two queries into a new table.\n   *\n   * A `lateral` join allows the right-hand expression to refer to columns from the left-hand side.\n   *\n   * Calling this method retrieves all rows from both main and joined queries, merging all rows from each query.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/joins#cross-join-lateral}\n   *\n   * @param table the query to join.\n   */\n  crossJoinLateral = this.createJoin(\"cross\", true);\n  createSetOperator(type, isAll) {\n    return (rightSelection) => {\n      const rightSelect = typeof rightSelection === \"function\" ? rightSelection(getPgSetOperators()) : rightSelection;\n      if (!haveSameKeys(this.getSelectedFields(), rightSelect.getSelectedFields())) {\n        throw new Error(\n          \"Set operator error (union / intersect / except): selected fields are not the same or are in a different order\"\n        );\n      }\n      this.config.setOperators.push({ type, isAll, rightSelect });\n      return this;\n    };\n  }\n  /**\n   * Adds `union` set operator to the query.\n   *\n   * Calling this method will combine the result sets of the `select` statements and remove any duplicate rows that appear across them.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/set-operations#union}\n   *\n   * @example\n   *\n   * ```ts\n   * // Select all unique names from customers and users tables\n   * await db.select({ name: users.name })\n   *   .from(users)\n   *   .union(\n   *     db.select({ name: customers.name }).from(customers)\n   *   );\n   * // or\n   * import { union } from 'drizzle-orm/pg-core'\n   *\n   * await union(\n   *   db.select({ name: users.name }).from(users),\n   *   db.select({ name: customers.name }).from(customers)\n   * );\n   * ```\n   */\n  union = this.createSetOperator(\"union\", false);\n  /**\n   * Adds `union all` set operator to the query.\n   *\n   * Calling this method will combine the result-set of the `select` statements and keep all duplicate rows that appear across them.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/set-operations#union-all}\n   *\n   * @example\n   *\n   * ```ts\n   * // Select all transaction ids from both online and in-store sales\n   * await db.select({ transaction: onlineSales.transactionId })\n   *   .from(onlineSales)\n   *   .unionAll(\n   *     db.select({ transaction: inStoreSales.transactionId }).from(inStoreSales)\n   *   );\n   * // or\n   * import { unionAll } from 'drizzle-orm/pg-core'\n   *\n   * await unionAll(\n   *   db.select({ transaction: onlineSales.transactionId }).from(onlineSales),\n   *   db.select({ transaction: inStoreSales.transactionId }).from(inStoreSales)\n   * );\n   * ```\n   */\n  unionAll = this.createSetOperator(\"union\", true);\n  /**\n   * Adds `intersect` set operator to the query.\n   *\n   * Calling this method will retain only the rows that are present in both result sets and eliminate duplicates.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/set-operations#intersect}\n   *\n   * @example\n   *\n   * ```ts\n   * // Select course names that are offered in both departments A and B\n   * await db.select({ courseName: depA.courseName })\n   *   .from(depA)\n   *   .intersect(\n   *     db.select({ courseName: depB.courseName }).from(depB)\n   *   );\n   * // or\n   * import { intersect } from 'drizzle-orm/pg-core'\n   *\n   * await intersect(\n   *   db.select({ courseName: depA.courseName }).from(depA),\n   *   db.select({ courseName: depB.courseName }).from(depB)\n   * );\n   * ```\n   */\n  intersect = this.createSetOperator(\"intersect\", false);\n  /**\n   * Adds `intersect all` set operator to the query.\n   *\n   * Calling this method will retain only the rows that are present in both result sets including all duplicates.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/set-operations#intersect-all}\n   *\n   * @example\n   *\n   * ```ts\n   * // Select all products and quantities that are ordered by both regular and VIP customers\n   * await db.select({\n   *   productId: regularCustomerOrders.productId,\n   *   quantityOrdered: regularCustomerOrders.quantityOrdered\n   * })\n   * .from(regularCustomerOrders)\n   * .intersectAll(\n   *   db.select({\n   *     productId: vipCustomerOrders.productId,\n   *     quantityOrdered: vipCustomerOrders.quantityOrdered\n   *   })\n   *   .from(vipCustomerOrders)\n   * );\n   * // or\n   * import { intersectAll } from 'drizzle-orm/pg-core'\n   *\n   * await intersectAll(\n   *   db.select({\n   *     productId: regularCustomerOrders.productId,\n   *     quantityOrdered: regularCustomerOrders.quantityOrdered\n   *   })\n   *   .from(regularCustomerOrders),\n   *   db.select({\n   *     productId: vipCustomerOrders.productId,\n   *     quantityOrdered: vipCustomerOrders.quantityOrdered\n   *   })\n   *   .from(vipCustomerOrders)\n   * );\n   * ```\n   */\n  intersectAll = this.createSetOperator(\"intersect\", true);\n  /**\n   * Adds `except` set operator to the query.\n   *\n   * Calling this method will retrieve all unique rows from the left query, except for the rows that are present in the result set of the right query.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/set-operations#except}\n   *\n   * @example\n   *\n   * ```ts\n   * // Select all courses offered in department A but not in department B\n   * await db.select({ courseName: depA.courseName })\n   *   .from(depA)\n   *   .except(\n   *     db.select({ courseName: depB.courseName }).from(depB)\n   *   );\n   * // or\n   * import { except } from 'drizzle-orm/pg-core'\n   *\n   * await except(\n   *   db.select({ courseName: depA.courseName }).from(depA),\n   *   db.select({ courseName: depB.courseName }).from(depB)\n   * );\n   * ```\n   */\n  except = this.createSetOperator(\"except\", false);\n  /**\n   * Adds `except all` set operator to the query.\n   *\n   * Calling this method will retrieve all rows from the left query, except for the rows that are present in the result set of the right query.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/set-operations#except-all}\n   *\n   * @example\n   *\n   * ```ts\n   * // Select all products that are ordered by regular customers but not by VIP customers\n   * await db.select({\n   *   productId: regularCustomerOrders.productId,\n   *   quantityOrdered: regularCustomerOrders.quantityOrdered,\n   * })\n   * .from(regularCustomerOrders)\n   * .exceptAll(\n   *   db.select({\n   *     productId: vipCustomerOrders.productId,\n   *     quantityOrdered: vipCustomerOrders.quantityOrdered,\n   *   })\n   *   .from(vipCustomerOrders)\n   * );\n   * // or\n   * import { exceptAll } from 'drizzle-orm/pg-core'\n   *\n   * await exceptAll(\n   *   db.select({\n   *     productId: regularCustomerOrders.productId,\n   *     quantityOrdered: regularCustomerOrders.quantityOrdered\n   *   })\n   *   .from(regularCustomerOrders),\n   *   db.select({\n   *     productId: vipCustomerOrders.productId,\n   *     quantityOrdered: vipCustomerOrders.quantityOrdered\n   *   })\n   *   .from(vipCustomerOrders)\n   * );\n   * ```\n   */\n  exceptAll = this.createSetOperator(\"except\", true);\n  /** @internal */\n  addSetOperators(setOperators) {\n    this.config.setOperators.push(...setOperators);\n    return this;\n  }\n  /**\n   * Adds a `where` clause to the query.\n   *\n   * Calling this method will select only those rows that fulfill a specified condition.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/select#filtering}\n   *\n   * @param where the `where` clause.\n   *\n   * @example\n   * You can use conditional operators and `sql function` to filter the rows to be selected.\n   *\n   * ```ts\n   * // Select all cars with green color\n   * await db.select().from(cars).where(eq(cars.color, 'green'));\n   * // or\n   * await db.select().from(cars).where(sql`${cars.color} = 'green'`)\n   * ```\n   *\n   * You can logically combine conditional operators with `and()` and `or()` operators:\n   *\n   * ```ts\n   * // Select all BMW cars with a green color\n   * await db.select().from(cars).where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));\n   *\n   * // Select all cars with the green or blue color\n   * await db.select().from(cars).where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));\n   * ```\n   */\n  where(where) {\n    if (typeof where === \"function\") {\n      where = where(\n        new Proxy(\n          this.config.fields,\n          new SelectionProxyHandler({ sqlAliasedBehavior: \"sql\", sqlBehavior: \"sql\" })\n        )\n      );\n    }\n    this.config.where = where;\n    return this;\n  }\n  /**\n   * Adds a `having` clause to the query.\n   *\n   * Calling this method will select only those rows that fulfill a specified condition. It is typically used with aggregate functions to filter the aggregated data based on a specified condition.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/select#aggregations}\n   *\n   * @param having the `having` clause.\n   *\n   * @example\n   *\n   * ```ts\n   * // Select all brands with more than one car\n   * await db.select({\n   * \tbrand: cars.brand,\n   * \tcount: sql<number>`cast(count(${cars.id}) as int)`,\n   * })\n   *   .from(cars)\n   *   .groupBy(cars.brand)\n   *   .having(({ count }) => gt(count, 1));\n   * ```\n   */\n  having(having) {\n    if (typeof having === \"function\") {\n      having = having(\n        new Proxy(\n          this.config.fields,\n          new SelectionProxyHandler({ sqlAliasedBehavior: \"sql\", sqlBehavior: \"sql\" })\n        )\n      );\n    }\n    this.config.having = having;\n    return this;\n  }\n  groupBy(...columns) {\n    if (typeof columns[0] === \"function\") {\n      const groupBy = columns[0](\n        new Proxy(\n          this.config.fields,\n          new SelectionProxyHandler({ sqlAliasedBehavior: \"alias\", sqlBehavior: \"sql\" })\n        )\n      );\n      this.config.groupBy = Array.isArray(groupBy) ? groupBy : [groupBy];\n    } else {\n      this.config.groupBy = columns;\n    }\n    return this;\n  }\n  orderBy(...columns) {\n    if (typeof columns[0] === \"function\") {\n      const orderBy = columns[0](\n        new Proxy(\n          this.config.fields,\n          new SelectionProxyHandler({ sqlAliasedBehavior: \"alias\", sqlBehavior: \"sql\" })\n        )\n      );\n      const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];\n      if (this.config.setOperators.length > 0) {\n        this.config.setOperators.at(-1).orderBy = orderByArray;\n      } else {\n        this.config.orderBy = orderByArray;\n      }\n    } else {\n      const orderByArray = columns;\n      if (this.config.setOperators.length > 0) {\n        this.config.setOperators.at(-1).orderBy = orderByArray;\n      } else {\n        this.config.orderBy = orderByArray;\n      }\n    }\n    return this;\n  }\n  /**\n   * Adds a `limit` clause to the query.\n   *\n   * Calling this method will set the maximum number of rows that will be returned by this query.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/select#limit--offset}\n   *\n   * @param limit the `limit` clause.\n   *\n   * @example\n   *\n   * ```ts\n   * // Get the first 10 people from this query.\n   * await db.select().from(people).limit(10);\n   * ```\n   */\n  limit(limit) {\n    if (this.config.setOperators.length > 0) {\n      this.config.setOperators.at(-1).limit = limit;\n    } else {\n      this.config.limit = limit;\n    }\n    return this;\n  }\n  /**\n   * Adds an `offset` clause to the query.\n   *\n   * Calling this method will skip a number of rows when returning results from this query.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/select#limit--offset}\n   *\n   * @param offset the `offset` clause.\n   *\n   * @example\n   *\n   * ```ts\n   * // Get the 10th-20th people from this query.\n   * await db.select().from(people).offset(10).limit(10);\n   * ```\n   */\n  offset(offset) {\n    if (this.config.setOperators.length > 0) {\n      this.config.setOperators.at(-1).offset = offset;\n    } else {\n      this.config.offset = offset;\n    }\n    return this;\n  }\n  /**\n   * Adds a `for` clause to the query.\n   *\n   * Calling this method will specify a lock strength for this query that controls how strictly it acquires exclusive access to the rows being queried.\n   *\n   * See docs: {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-FOR-UPDATE-SHARE}\n   *\n   * @param strength the lock strength.\n   * @param config the lock configuration.\n   */\n  for(strength, config = {}) {\n    this.config.lockingClause = { strength, config };\n    return this;\n  }\n  /** @internal */\n  getSQL() {\n    return this.dialect.buildSelectQuery(this.config);\n  }\n  toSQL() {\n    const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());\n    return rest;\n  }\n  as(alias) {\n    const usedTables = [];\n    usedTables.push(...extractUsedTable(this.config.table));\n    if (this.config.joins) {\n      for (const it of this.config.joins) usedTables.push(...extractUsedTable(it.table));\n    }\n    return new Proxy(\n      new Subquery(this.getSQL(), this.config.fields, alias, false, [...new Set(usedTables)]),\n      new SelectionProxyHandler({ alias, sqlAliasedBehavior: \"alias\", sqlBehavior: \"error\" })\n    );\n  }\n  /** @internal */\n  getSelectedFields() {\n    return new Proxy(\n      this.config.fields,\n      new SelectionProxyHandler({ alias: this.tableName, sqlAliasedBehavior: \"alias\", sqlBehavior: \"error\" })\n    );\n  }\n  $dynamic() {\n    return this;\n  }\n  $withCache(config) {\n    this.cacheConfig = config === void 0 ? { config: {}, enable: true, autoInvalidate: true } : config === false ? { enable: false } : { enable: true, autoInvalidate: true, ...config };\n    return this;\n  }\n}\nclass PgSelectBase extends PgSelectQueryBuilderBase {\n  static [entityKind] = \"PgSelect\";\n  /** @internal */\n  _prepare(name) {\n    const { session, config, dialect, joinsNotNullableMap, authToken, cacheConfig, usedTables } = this;\n    if (!session) {\n      throw new Error(\"Cannot execute a query on a query builder. Please use a database instance instead.\");\n    }\n    const { fields } = config;\n    return tracer.startActiveSpan(\"drizzle.prepareQuery\", () => {\n      const fieldsList = orderSelectedFields(fields);\n      const query = session.prepareQuery(dialect.sqlToQuery(this.getSQL()), fieldsList, name, true, void 0, {\n        type: \"select\",\n        tables: [...usedTables]\n      }, cacheConfig);\n      query.joinsNotNullableMap = joinsNotNullableMap;\n      return query.setToken(authToken);\n    });\n  }\n  /**\n   * Create a prepared statement for this query. This allows\n   * the database to remember this query for the given session\n   * and call it by name, rather than specifying the full query.\n   *\n   * {@link https://www.postgresql.org/docs/current/sql-prepare.html | Postgres prepare documentation}\n   */\n  prepare(name) {\n    return this._prepare(name);\n  }\n  authToken;\n  /** @internal */\n  setToken(token) {\n    this.authToken = token;\n    return this;\n  }\n  execute = (placeholderValues) => {\n    return tracer.startActiveSpan(\"drizzle.operation\", () => {\n      return this._prepare().execute(placeholderValues, this.authToken);\n    });\n  };\n}\napplyMixins(PgSelectBase, [QueryPromise]);\nfunction createSetOperator(type, isAll) {\n  return (leftSelect, rightSelect, ...restSelects) => {\n    const setOperators = [rightSelect, ...restSelects].map((select) => ({\n      type,\n      isAll,\n      rightSelect: select\n    }));\n    for (const setOperator of setOperators) {\n      if (!haveSameKeys(leftSelect.getSelectedFields(), setOperator.rightSelect.getSelectedFields())) {\n        throw new Error(\n          \"Set operator error (union / intersect / except): selected fields are not the same or are in a different order\"\n        );\n      }\n    }\n    return leftSelect.addSetOperators(setOperators);\n  };\n}\nconst getPgSetOperators = () => ({\n  union,\n  unionAll,\n  intersect,\n  intersectAll,\n  except,\n  exceptAll\n});\nconst union = createSetOperator(\"union\", false);\nconst unionAll = createSetOperator(\"union\", true);\nconst intersect = createSetOperator(\"intersect\", false);\nconst intersectAll = createSetOperator(\"intersect\", true);\nconst except = createSetOperator(\"except\", false);\nconst exceptAll = createSetOperator(\"except\", true);\nexport {\n  PgSelectBase,\n  PgSelectBuilder,\n  PgSelectQueryBuilderBase,\n  except,\n  exceptAll,\n  intersect,\n  intersectAll,\n  union,\n  unionAll\n};\n//# sourceMappingURL=select.js.map"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/node/node_modules/.pnpm/drizzle-orm@0.44.7_@electric-sql_pglite@0.3.15_@libsql_client@0.14.0_@prisma_client@6.1_945233f0b9a56e69a65134d4c5811e1b/node_modules/drizzle-orm/pg-core/query-builders/update.js

@@ -0,0 +1,201 @@
+import { entityKind, is } from "../../entity.js";
+import { QueryPromise } from "../../query-promise.js";
+import { Subquery } from "../../subquery.js";
+import { ViewBaseConfig } from "../../view-common.js";
+import { Table, getTableName } from "../../table.js";
+import { SQL } from "../../sql/sql.js";
+import { SelectionProxyHandler } from "../../selection-proxy.js";
+import { getTableLikeName, mapUpdateSet, orderSelectedFields } from "../../utils.js";
+import { PgTable } from "../table.js";
+import { extractUsedTable } from "../utils.js";
+
+//#region ../../node_modules/.pnpm/drizzle-orm@0.44.7_@electric-sql+pglite@0.3.15_@libsql+client@0.14.0_@prisma+client@6.1_945233f0b9a56e69a65134d4c5811e1b/node_modules/drizzle-orm/pg-core/query-builders/update.js
+var PgUpdateBuilder = class {
+	constructor(table, session, dialect, withList) {
+		this.table = table;
+		this.session = session;
+		this.dialect = dialect;
+		this.withList = withList;
+	}
+	static [entityKind] = "PgUpdateBuilder";
+	authToken;
+	setToken(token) {
+		this.authToken = token;
+		return this;
+	}
+	set(values) {
+		return new PgUpdateBase(this.table, mapUpdateSet(this.table, values), this.session, this.dialect, this.withList).setToken(this.authToken);
+	}
+};
+var PgUpdateBase = class extends QueryPromise {
+	constructor(table, set, session, dialect, withList) {
+		super();
+		this.session = session;
+		this.dialect = dialect;
+		this.config = {
+			set,
+			table,
+			withList,
+			joins: []
+		};
+		this.tableName = getTableLikeName(table);
+		this.joinsNotNullableMap = typeof this.tableName === "string" ? { [this.tableName]: true } : {};
+	}
+	static [entityKind] = "PgUpdate";
+	config;
+	tableName;
+	joinsNotNullableMap;
+	cacheConfig;
+	from(source) {
+		const src = source;
+		const tableName = getTableLikeName(src);
+		if (typeof tableName === "string") this.joinsNotNullableMap[tableName] = true;
+		this.config.from = src;
+		return this;
+	}
+	getTableLikeFields(table) {
+		if (is(table, PgTable)) return table[Table.Symbol.Columns];
+		else if (is(table, Subquery)) return table._.selectedFields;
+		return table[ViewBaseConfig].selectedFields;
+	}
+	createJoin(joinType) {
+		return (table, on) => {
+			const tableName = getTableLikeName(table);
+			if (typeof tableName === "string" && this.config.joins.some((join) => join.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
+			if (typeof on === "function") {
+				const from = this.config.from && !is(this.config.from, SQL) ? this.getTableLikeFields(this.config.from) : void 0;
+				on = on(new Proxy(this.config.table[Table.Symbol.Columns], new SelectionProxyHandler({
+					sqlAliasedBehavior: "sql",
+					sqlBehavior: "sql"
+				})), from && new Proxy(from, new SelectionProxyHandler({
+					sqlAliasedBehavior: "sql",
+					sqlBehavior: "sql"
+				})));
+			}
+			this.config.joins.push({
+				on,
+				table,
+				joinType,
+				alias: tableName
+			});
+			if (typeof tableName === "string") switch (joinType) {
+				case "left":
+					this.joinsNotNullableMap[tableName] = false;
+					break;
+				case "right":
+					this.joinsNotNullableMap = Object.fromEntries(Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false]));
+					this.joinsNotNullableMap[tableName] = true;
+					break;
+				case "inner":
+					this.joinsNotNullableMap[tableName] = true;
+					break;
+				case "full":
+					this.joinsNotNullableMap = Object.fromEntries(Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false]));
+					this.joinsNotNullableMap[tableName] = false;
+					break;
+			}
+			return this;
+		};
+	}
+	leftJoin = this.createJoin("left");
+	rightJoin = this.createJoin("right");
+	innerJoin = this.createJoin("inner");
+	fullJoin = this.createJoin("full");
+	/**
+	* Adds a 'where' clause to the query.
+	*
+	* Calling this method will update only those rows that fulfill a specified condition.
+	*
+	* See docs: {@link https://orm.drizzle.team/docs/update}
+	*
+	* @param where the 'where' clause.
+	*
+	* @example
+	* You can use conditional operators and `sql function` to filter the rows to be updated.
+	*
+	* ```ts
+	* // Update all cars with green color
+	* await db.update(cars).set({ color: 'red' })
+	*   .where(eq(cars.color, 'green'));
+	* // or
+	* await db.update(cars).set({ color: 'red' })
+	*   .where(sql`${cars.color} = 'green'`)
+	* ```
+	*
+	* You can logically combine conditional operators with `and()` and `or()` operators:
+	*
+	* ```ts
+	* // Update all BMW cars with a green color
+	* await db.update(cars).set({ color: 'red' })
+	*   .where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
+	*
+	* // Update all cars with the green or blue color
+	* await db.update(cars).set({ color: 'red' })
+	*   .where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
+	* ```
+	*/
+	where(where) {
+		this.config.where = where;
+		return this;
+	}
+	returning(fields) {
+		if (!fields) {
+			fields = Object.assign({}, this.config.table[Table.Symbol.Columns]);
+			if (this.config.from) {
+				const tableName = getTableLikeName(this.config.from);
+				if (typeof tableName === "string" && this.config.from && !is(this.config.from, SQL)) fields[tableName] = this.getTableLikeFields(this.config.from);
+				for (const join of this.config.joins) {
+					const tableName2 = getTableLikeName(join.table);
+					if (typeof tableName2 === "string" && !is(join.table, SQL)) fields[tableName2] = this.getTableLikeFields(join.table);
+				}
+			}
+		}
+		this.config.returningFields = fields;
+		this.config.returning = orderSelectedFields(fields);
+		return this;
+	}
+	/** @internal */
+	getSQL() {
+		return this.dialect.buildUpdateQuery(this.config);
+	}
+	toSQL() {
+		const { typings: _typings,...rest } = this.dialect.sqlToQuery(this.getSQL());
+		return rest;
+	}
+	/** @internal */
+	_prepare(name) {
+		const query = this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), this.config.returning, name, true, void 0, {
+			type: "insert",
+			tables: extractUsedTable(this.config.table)
+		}, this.cacheConfig);
+		query.joinsNotNullableMap = this.joinsNotNullableMap;
+		return query;
+	}
+	prepare(name) {
+		return this._prepare(name);
+	}
+	authToken;
+	/** @internal */
+	setToken(token) {
+		this.authToken = token;
+		return this;
+	}
+	execute = (placeholderValues) => {
+		return this._prepare().execute(placeholderValues, this.authToken);
+	};
+	/** @internal */
+	getSelectedFields() {
+		return this.config.returningFields ? new Proxy(this.config.returningFields, new SelectionProxyHandler({
+			alias: getTableName(this.config.table),
+			sqlAliasedBehavior: "alias",
+			sqlBehavior: "error"
+		})) : void 0;
+	}
+	$dynamic() {
+		return this;
+	}
+};
+
+//#endregion
+export { PgUpdateBuilder };
+//# sourceMappingURL=update.js.map

package/dist/node/node_modules/.pnpm/drizzle-orm@0.44.7_@electric-sql_pglite@0.3.15_@libsql_client@0.14.0_@prisma_client@6.1_945233f0b9a56e69a65134d4c5811e1b/node_modules/drizzle-orm/pg-core/query-builders/update.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"update.js","names":[],"sources":["../../../../../../../../../../../node_modules/.pnpm/drizzle-orm@0.44.7_@electric-sql+pglite@0.3.15_@libsql+client@0.14.0_@prisma+client@6.1_945233f0b9a56e69a65134d4c5811e1b/node_modules/drizzle-orm/pg-core/query-builders/update.js"],"sourcesContent":["import { entityKind, is } from \"../../entity.js\";\nimport { PgTable } from \"../table.js\";\nimport { QueryPromise } from \"../../query-promise.js\";\nimport { SelectionProxyHandler } from \"../../selection-proxy.js\";\nimport { SQL } from \"../../sql/sql.js\";\nimport { Subquery } from \"../../subquery.js\";\nimport { getTableName, Table } from \"../../table.js\";\nimport {\n  getTableLikeName,\n  mapUpdateSet,\n  orderSelectedFields\n} from \"../../utils.js\";\nimport { ViewBaseConfig } from \"../../view-common.js\";\nimport { extractUsedTable } from \"../utils.js\";\nclass PgUpdateBuilder {\n  constructor(table, session, dialect, withList) {\n    this.table = table;\n    this.session = session;\n    this.dialect = dialect;\n    this.withList = withList;\n  }\n  static [entityKind] = \"PgUpdateBuilder\";\n  authToken;\n  setToken(token) {\n    this.authToken = token;\n    return this;\n  }\n  set(values) {\n    return new PgUpdateBase(\n      this.table,\n      mapUpdateSet(this.table, values),\n      this.session,\n      this.dialect,\n      this.withList\n    ).setToken(this.authToken);\n  }\n}\nclass PgUpdateBase extends QueryPromise {\n  constructor(table, set, session, dialect, withList) {\n    super();\n    this.session = session;\n    this.dialect = dialect;\n    this.config = { set, table, withList, joins: [] };\n    this.tableName = getTableLikeName(table);\n    this.joinsNotNullableMap = typeof this.tableName === \"string\" ? { [this.tableName]: true } : {};\n  }\n  static [entityKind] = \"PgUpdate\";\n  config;\n  tableName;\n  joinsNotNullableMap;\n  cacheConfig;\n  from(source) {\n    const src = source;\n    const tableName = getTableLikeName(src);\n    if (typeof tableName === \"string\") {\n      this.joinsNotNullableMap[tableName] = true;\n    }\n    this.config.from = src;\n    return this;\n  }\n  getTableLikeFields(table) {\n    if (is(table, PgTable)) {\n      return table[Table.Symbol.Columns];\n    } else if (is(table, Subquery)) {\n      return table._.selectedFields;\n    }\n    return table[ViewBaseConfig].selectedFields;\n  }\n  createJoin(joinType) {\n    return (table, on) => {\n      const tableName = getTableLikeName(table);\n      if (typeof tableName === \"string\" && this.config.joins.some((join) => join.alias === tableName)) {\n        throw new Error(`Alias \"${tableName}\" is already used in this query`);\n      }\n      if (typeof on === \"function\") {\n        const from = this.config.from && !is(this.config.from, SQL) ? this.getTableLikeFields(this.config.from) : void 0;\n        on = on(\n          new Proxy(\n            this.config.table[Table.Symbol.Columns],\n            new SelectionProxyHandler({ sqlAliasedBehavior: \"sql\", sqlBehavior: \"sql\" })\n          ),\n          from && new Proxy(\n            from,\n            new SelectionProxyHandler({ sqlAliasedBehavior: \"sql\", sqlBehavior: \"sql\" })\n          )\n        );\n      }\n      this.config.joins.push({ on, table, joinType, alias: tableName });\n      if (typeof tableName === \"string\") {\n        switch (joinType) {\n          case \"left\": {\n            this.joinsNotNullableMap[tableName] = false;\n            break;\n          }\n          case \"right\": {\n            this.joinsNotNullableMap = Object.fromEntries(\n              Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false])\n            );\n            this.joinsNotNullableMap[tableName] = true;\n            break;\n          }\n          case \"inner\": {\n            this.joinsNotNullableMap[tableName] = true;\n            break;\n          }\n          case \"full\": {\n            this.joinsNotNullableMap = Object.fromEntries(\n              Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false])\n            );\n            this.joinsNotNullableMap[tableName] = false;\n            break;\n          }\n        }\n      }\n      return this;\n    };\n  }\n  leftJoin = this.createJoin(\"left\");\n  rightJoin = this.createJoin(\"right\");\n  innerJoin = this.createJoin(\"inner\");\n  fullJoin = this.createJoin(\"full\");\n  /**\n   * Adds a 'where' clause to the query.\n   *\n   * Calling this method will update only those rows that fulfill a specified condition.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/update}\n   *\n   * @param where the 'where' clause.\n   *\n   * @example\n   * You can use conditional operators and `sql function` to filter the rows to be updated.\n   *\n   * ```ts\n   * // Update all cars with green color\n   * await db.update(cars).set({ color: 'red' })\n   *   .where(eq(cars.color, 'green'));\n   * // or\n   * await db.update(cars).set({ color: 'red' })\n   *   .where(sql`${cars.color} = 'green'`)\n   * ```\n   *\n   * You can logically combine conditional operators with `and()` and `or()` operators:\n   *\n   * ```ts\n   * // Update all BMW cars with a green color\n   * await db.update(cars).set({ color: 'red' })\n   *   .where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));\n   *\n   * // Update all cars with the green or blue color\n   * await db.update(cars).set({ color: 'red' })\n   *   .where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));\n   * ```\n   */\n  where(where) {\n    this.config.where = where;\n    return this;\n  }\n  returning(fields) {\n    if (!fields) {\n      fields = Object.assign({}, this.config.table[Table.Symbol.Columns]);\n      if (this.config.from) {\n        const tableName = getTableLikeName(this.config.from);\n        if (typeof tableName === \"string\" && this.config.from && !is(this.config.from, SQL)) {\n          const fromFields = this.getTableLikeFields(this.config.from);\n          fields[tableName] = fromFields;\n        }\n        for (const join of this.config.joins) {\n          const tableName2 = getTableLikeName(join.table);\n          if (typeof tableName2 === \"string\" && !is(join.table, SQL)) {\n            const fromFields = this.getTableLikeFields(join.table);\n            fields[tableName2] = fromFields;\n          }\n        }\n      }\n    }\n    this.config.returningFields = fields;\n    this.config.returning = orderSelectedFields(fields);\n    return this;\n  }\n  /** @internal */\n  getSQL() {\n    return this.dialect.buildUpdateQuery(this.config);\n  }\n  toSQL() {\n    const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());\n    return rest;\n  }\n  /** @internal */\n  _prepare(name) {\n    const query = this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), this.config.returning, name, true, void 0, {\n      type: \"insert\",\n      tables: extractUsedTable(this.config.table)\n    }, this.cacheConfig);\n    query.joinsNotNullableMap = this.joinsNotNullableMap;\n    return query;\n  }\n  prepare(name) {\n    return this._prepare(name);\n  }\n  authToken;\n  /** @internal */\n  setToken(token) {\n    this.authToken = token;\n    return this;\n  }\n  execute = (placeholderValues) => {\n    return this._prepare().execute(placeholderValues, this.authToken);\n  };\n  /** @internal */\n  getSelectedFields() {\n    return this.config.returningFields ? new Proxy(\n      this.config.returningFields,\n      new SelectionProxyHandler({\n        alias: getTableName(this.config.table),\n        sqlAliasedBehavior: \"alias\",\n        sqlBehavior: \"error\"\n      })\n    ) : void 0;\n  }\n  $dynamic() {\n    return this;\n  }\n}\nexport {\n  PgUpdateBase,\n  PgUpdateBuilder\n};\n//# sourceMappingURL=update.js.map"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/node/node_modules/.pnpm/drizzle-orm@0.44.7_@electric-sql_pglite@0.3.15_@libsql_client@0.14.0_@prisma_client@6.1_945233f0b9a56e69a65134d4c5811e1b/node_modules/drizzle-orm/pg-core/session.js

@@ -0,0 +1,127 @@
+import { entityKind, is } from "../entity.js";
+import { tracer } from "../tracing.js";
+import { sql } from "../sql/sql.js";
+import { DrizzleQueryError, TransactionRollbackError } from "../errors.js";
+import { PgDatabase } from "./db.js";
+import { NoopCache, hashQuery } from "../cache/core/cache.js";
+
+//#region ../../node_modules/.pnpm/drizzle-orm@0.44.7_@electric-sql+pglite@0.3.15_@libsql+client@0.14.0_@prisma+client@6.1_945233f0b9a56e69a65134d4c5811e1b/node_modules/drizzle-orm/pg-core/session.js
+var PgPreparedQuery = class {
+	constructor(query, cache, queryMetadata, cacheConfig) {
+		this.query = query;
+		this.cache = cache;
+		this.queryMetadata = queryMetadata;
+		this.cacheConfig = cacheConfig;
+		if (cache && cache.strategy() === "all" && cacheConfig === void 0) this.cacheConfig = {
+			enable: true,
+			autoInvalidate: true
+		};
+		if (!this.cacheConfig?.enable) this.cacheConfig = void 0;
+	}
+	authToken;
+	getQuery() {
+		return this.query;
+	}
+	mapResult(response, _isFromBatch) {
+		return response;
+	}
+	/** @internal */
+	setToken(token) {
+		this.authToken = token;
+		return this;
+	}
+	static [entityKind] = "PgPreparedQuery";
+	/** @internal */
+	joinsNotNullableMap;
+	/** @internal */
+	async queryWithCache(queryString, params, query) {
+		if (this.cache === void 0 || is(this.cache, NoopCache) || this.queryMetadata === void 0) try {
+			return await query();
+		} catch (e) {
+			throw new DrizzleQueryError(queryString, params, e);
+		}
+		if (this.cacheConfig && !this.cacheConfig.enable) try {
+			return await query();
+		} catch (e) {
+			throw new DrizzleQueryError(queryString, params, e);
+		}
+		if ((this.queryMetadata.type === "insert" || this.queryMetadata.type === "update" || this.queryMetadata.type === "delete") && this.queryMetadata.tables.length > 0) try {
+			const [res] = await Promise.all([query(), this.cache.onMutate({ tables: this.queryMetadata.tables })]);
+			return res;
+		} catch (e) {
+			throw new DrizzleQueryError(queryString, params, e);
+		}
+		if (!this.cacheConfig) try {
+			return await query();
+		} catch (e) {
+			throw new DrizzleQueryError(queryString, params, e);
+		}
+		if (this.queryMetadata.type === "select") {
+			const fromCache = await this.cache.get(this.cacheConfig.tag ?? await hashQuery(queryString, params), this.queryMetadata.tables, this.cacheConfig.tag !== void 0, this.cacheConfig.autoInvalidate);
+			if (fromCache === void 0) {
+				let result;
+				try {
+					result = await query();
+				} catch (e) {
+					throw new DrizzleQueryError(queryString, params, e);
+				}
+				await this.cache.put(this.cacheConfig.tag ?? await hashQuery(queryString, params), result, this.cacheConfig.autoInvalidate ? this.queryMetadata.tables : [], this.cacheConfig.tag !== void 0, this.cacheConfig.config);
+				return result;
+			}
+			return fromCache;
+		}
+		try {
+			return await query();
+		} catch (e) {
+			throw new DrizzleQueryError(queryString, params, e);
+		}
+	}
+};
+var PgSession = class {
+	constructor(dialect) {
+		this.dialect = dialect;
+	}
+	static [entityKind] = "PgSession";
+	/** @internal */
+	execute(query, token) {
+		return tracer.startActiveSpan("drizzle.operation", () => {
+			return tracer.startActiveSpan("drizzle.prepareQuery", () => {
+				return this.prepareQuery(this.dialect.sqlToQuery(query), void 0, void 0, false);
+			}).setToken(token).execute(void 0, token);
+		});
+	}
+	all(query) {
+		return this.prepareQuery(this.dialect.sqlToQuery(query), void 0, void 0, false).all();
+	}
+	/** @internal */
+	async count(sql2, token) {
+		const res = await this.execute(sql2, token);
+		return Number(res[0]["count"]);
+	}
+};
+var PgTransaction = class extends PgDatabase {
+	constructor(dialect, session, schema, nestedIndex = 0) {
+		super(dialect, session, schema);
+		this.schema = schema;
+		this.nestedIndex = nestedIndex;
+	}
+	static [entityKind] = "PgTransaction";
+	rollback() {
+		throw new TransactionRollbackError();
+	}
+	/** @internal */
+	getTransactionConfigSQL(config) {
+		const chunks = [];
+		if (config.isolationLevel) chunks.push(`isolation level ${config.isolationLevel}`);
+		if (config.accessMode) chunks.push(config.accessMode);
+		if (typeof config.deferrable === "boolean") chunks.push(config.deferrable ? "deferrable" : "not deferrable");
+		return sql.raw(chunks.join(" "));
+	}
+	setTransaction(config) {
+		return this.session.execute(sql`set transaction ${this.getTransactionConfigSQL(config)}`);
+	}
+};
+
+//#endregion
+export { PgPreparedQuery, PgSession, PgTransaction };
+//# sourceMappingURL=session.js.map

package/dist/node/node_modules/.pnpm/drizzle-orm@0.44.7_@electric-sql_pglite@0.3.15_@libsql_client@0.14.0_@prisma_client@6.1_945233f0b9a56e69a65134d4c5811e1b/node_modules/drizzle-orm/pg-core/session.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.js","names":[],"sources":["../../../../../../../../../../node_modules/.pnpm/drizzle-orm@0.44.7_@electric-sql+pglite@0.3.15_@libsql+client@0.14.0_@prisma+client@6.1_945233f0b9a56e69a65134d4c5811e1b/node_modules/drizzle-orm/pg-core/session.js"],"sourcesContent":["import { hashQuery, NoopCache } from \"../cache/core/cache.js\";\nimport { entityKind, is } from \"../entity.js\";\nimport { DrizzleQueryError, TransactionRollbackError } from \"../errors.js\";\nimport { sql } from \"../sql/index.js\";\nimport { tracer } from \"../tracing.js\";\nimport { PgDatabase } from \"./db.js\";\nclass PgPreparedQuery {\n  constructor(query, cache, queryMetadata, cacheConfig) {\n    this.query = query;\n    this.cache = cache;\n    this.queryMetadata = queryMetadata;\n    this.cacheConfig = cacheConfig;\n    if (cache && cache.strategy() === \"all\" && cacheConfig === void 0) {\n      this.cacheConfig = { enable: true, autoInvalidate: true };\n    }\n    if (!this.cacheConfig?.enable) {\n      this.cacheConfig = void 0;\n    }\n  }\n  authToken;\n  getQuery() {\n    return this.query;\n  }\n  mapResult(response, _isFromBatch) {\n    return response;\n  }\n  /** @internal */\n  setToken(token) {\n    this.authToken = token;\n    return this;\n  }\n  static [entityKind] = \"PgPreparedQuery\";\n  /** @internal */\n  joinsNotNullableMap;\n  /** @internal */\n  async queryWithCache(queryString, params, query) {\n    if (this.cache === void 0 || is(this.cache, NoopCache) || this.queryMetadata === void 0) {\n      try {\n        return await query();\n      } catch (e) {\n        throw new DrizzleQueryError(queryString, params, e);\n      }\n    }\n    if (this.cacheConfig && !this.cacheConfig.enable) {\n      try {\n        return await query();\n      } catch (e) {\n        throw new DrizzleQueryError(queryString, params, e);\n      }\n    }\n    if ((this.queryMetadata.type === \"insert\" || this.queryMetadata.type === \"update\" || this.queryMetadata.type === \"delete\") && this.queryMetadata.tables.length > 0) {\n      try {\n        const [res] = await Promise.all([\n          query(),\n          this.cache.onMutate({ tables: this.queryMetadata.tables })\n        ]);\n        return res;\n      } catch (e) {\n        throw new DrizzleQueryError(queryString, params, e);\n      }\n    }\n    if (!this.cacheConfig) {\n      try {\n        return await query();\n      } catch (e) {\n        throw new DrizzleQueryError(queryString, params, e);\n      }\n    }\n    if (this.queryMetadata.type === \"select\") {\n      const fromCache = await this.cache.get(\n        this.cacheConfig.tag ?? (await hashQuery(queryString, params)),\n        this.queryMetadata.tables,\n        this.cacheConfig.tag !== void 0,\n        this.cacheConfig.autoInvalidate\n      );\n      if (fromCache === void 0) {\n        let result;\n        try {\n          result = await query();\n        } catch (e) {\n          throw new DrizzleQueryError(queryString, params, e);\n        }\n        await this.cache.put(\n          this.cacheConfig.tag ?? (await hashQuery(queryString, params)),\n          result,\n          // make sure we send tables that were used in a query only if user wants to invalidate it on each write\n          this.cacheConfig.autoInvalidate ? this.queryMetadata.tables : [],\n          this.cacheConfig.tag !== void 0,\n          this.cacheConfig.config\n        );\n        return result;\n      }\n      return fromCache;\n    }\n    try {\n      return await query();\n    } catch (e) {\n      throw new DrizzleQueryError(queryString, params, e);\n    }\n  }\n}\nclass PgSession {\n  constructor(dialect) {\n    this.dialect = dialect;\n  }\n  static [entityKind] = \"PgSession\";\n  /** @internal */\n  execute(query, token) {\n    return tracer.startActiveSpan(\"drizzle.operation\", () => {\n      const prepared = tracer.startActiveSpan(\"drizzle.prepareQuery\", () => {\n        return this.prepareQuery(\n          this.dialect.sqlToQuery(query),\n          void 0,\n          void 0,\n          false\n        );\n      });\n      return prepared.setToken(token).execute(void 0, token);\n    });\n  }\n  all(query) {\n    return this.prepareQuery(\n      this.dialect.sqlToQuery(query),\n      void 0,\n      void 0,\n      false\n    ).all();\n  }\n  /** @internal */\n  async count(sql2, token) {\n    const res = await this.execute(sql2, token);\n    return Number(\n      res[0][\"count\"]\n    );\n  }\n}\nclass PgTransaction extends PgDatabase {\n  constructor(dialect, session, schema, nestedIndex = 0) {\n    super(dialect, session, schema);\n    this.schema = schema;\n    this.nestedIndex = nestedIndex;\n  }\n  static [entityKind] = \"PgTransaction\";\n  rollback() {\n    throw new TransactionRollbackError();\n  }\n  /** @internal */\n  getTransactionConfigSQL(config) {\n    const chunks = [];\n    if (config.isolationLevel) {\n      chunks.push(`isolation level ${config.isolationLevel}`);\n    }\n    if (config.accessMode) {\n      chunks.push(config.accessMode);\n    }\n    if (typeof config.deferrable === \"boolean\") {\n      chunks.push(config.deferrable ? \"deferrable\" : \"not deferrable\");\n    }\n    return sql.raw(chunks.join(\" \"));\n  }\n  setTransaction(config) {\n    return this.session.execute(sql`set transaction ${this.getTransactionConfigSQL(config)}`);\n  }\n}\nexport {\n  PgPreparedQuery,\n  PgSession,\n  PgTransaction\n};\n//# sourceMappingURL=session.js.map"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/node/node_modules/.pnpm/drizzle-orm@0.44.7_@electric-sql_pglite@0.3.15_@libsql_client@0.14.0_@prisma_client@6.1_945233f0b9a56e69a65134d4c5811e1b/node_modules/drizzle-orm/pg-core/table.js

@@ -0,0 +1,26 @@
+import { entityKind } from "../entity.js";
+import { Table } from "../table.js";
+
+//#region ../../node_modules/.pnpm/drizzle-orm@0.44.7_@electric-sql+pglite@0.3.15_@libsql+client@0.14.0_@prisma+client@6.1_945233f0b9a56e69a65134d4c5811e1b/node_modules/drizzle-orm/pg-core/table.js
+const InlineForeignKeys = Symbol.for("drizzle:PgInlineForeignKeys");
+const EnableRLS = Symbol.for("drizzle:EnableRLS");
+var PgTable = class extends Table {
+	static [entityKind] = "PgTable";
+	/** @internal */
+	static Symbol = Object.assign({}, Table.Symbol, {
+		InlineForeignKeys,
+		EnableRLS
+	});
+	/**@internal */
+	[InlineForeignKeys] = [];
+	/** @internal */
+	[EnableRLS] = false;
+	/** @internal */
+	[Table.Symbol.ExtraConfigBuilder] = void 0;
+	/** @internal */
+	[Table.Symbol.ExtraConfigColumns] = {};
+};
+
+//#endregion
+export { PgTable };
+//# sourceMappingURL=table.js.map

package/dist/node/node_modules/.pnpm/drizzle-orm@0.44.7_@electric-sql_pglite@0.3.15_@libsql_client@0.14.0_@prisma_client@6.1_945233f0b9a56e69a65134d4c5811e1b/node_modules/drizzle-orm/pg-core/table.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.js","names":[],"sources":["../../../../../../../../../../node_modules/.pnpm/drizzle-orm@0.44.7_@electric-sql+pglite@0.3.15_@libsql+client@0.14.0_@prisma+client@6.1_945233f0b9a56e69a65134d4c5811e1b/node_modules/drizzle-orm/pg-core/table.js"],"sourcesContent":["import { entityKind } from \"../entity.js\";\nimport { Table } from \"../table.js\";\nimport { getPgColumnBuilders } from \"./columns/all.js\";\nconst InlineForeignKeys = Symbol.for(\"drizzle:PgInlineForeignKeys\");\nconst EnableRLS = Symbol.for(\"drizzle:EnableRLS\");\nclass PgTable extends Table {\n  static [entityKind] = \"PgTable\";\n  /** @internal */\n  static Symbol = Object.assign({}, Table.Symbol, {\n    InlineForeignKeys,\n    EnableRLS\n  });\n  /**@internal */\n  [InlineForeignKeys] = [];\n  /** @internal */\n  [EnableRLS] = false;\n  /** @internal */\n  [Table.Symbol.ExtraConfigBuilder] = void 0;\n  /** @internal */\n  [Table.Symbol.ExtraConfigColumns] = {};\n}\nfunction pgTableWithSchema(name, columns, extraConfig, schema, baseName = name) {\n  const rawTable = new PgTable(name, schema, baseName);\n  const parsedColumns = typeof columns === \"function\" ? columns(getPgColumnBuilders()) : columns;\n  const builtColumns = Object.fromEntries(\n    Object.entries(parsedColumns).map(([name2, colBuilderBase]) => {\n      const colBuilder = colBuilderBase;\n      colBuilder.setName(name2);\n      const column = colBuilder.build(rawTable);\n      rawTable[InlineForeignKeys].push(...colBuilder.buildForeignKeys(column, rawTable));\n      return [name2, column];\n    })\n  );\n  const builtColumnsForExtraConfig = Object.fromEntries(\n    Object.entries(parsedColumns).map(([name2, colBuilderBase]) => {\n      const colBuilder = colBuilderBase;\n      colBuilder.setName(name2);\n      const column = colBuilder.buildExtraConfigColumn(rawTable);\n      return [name2, column];\n    })\n  );\n  const table = Object.assign(rawTable, builtColumns);\n  table[Table.Symbol.Columns] = builtColumns;\n  table[Table.Symbol.ExtraConfigColumns] = builtColumnsForExtraConfig;\n  if (extraConfig) {\n    table[PgTable.Symbol.ExtraConfigBuilder] = extraConfig;\n  }\n  return Object.assign(table, {\n    enableRLS: () => {\n      table[PgTable.Symbol.EnableRLS] = true;\n      return table;\n    }\n  });\n}\nconst pgTable = (name, columns, extraConfig) => {\n  return pgTableWithSchema(name, columns, extraConfig, void 0);\n};\nfunction pgTableCreator(customizeTableName) {\n  return (name, columns, extraConfig) => {\n    return pgTableWithSchema(customizeTableName(name), columns, extraConfig, void 0, name);\n  };\n}\nexport {\n  EnableRLS,\n  InlineForeignKeys,\n  PgTable,\n  pgTable,\n  pgTableCreator,\n  pgTableWithSchema\n};\n//# sourceMappingURL=table.js.map"],"x_google_ignoreList":[0],"mappings":";;;;AAGA,MAAM,oBAAoB,OAAO,IAAI,8BAA8B;AACnE,MAAM,YAAY,OAAO,IAAI,oBAAoB;AACjD,IAAM,UAAN,cAAsB,MAAM;CAC1B,QAAQ,cAAc;;CAEtB,OAAO,SAAS,OAAO,OAAO,EAAE,EAAE,MAAM,QAAQ;EAC9C;EACA;EACD,CAAC;;CAEF,CAAC,qBAAqB,EAAE;;CAExB,CAAC,aAAa;;CAEd,CAAC,MAAM,OAAO,sBAAsB,KAAK;;CAEzC,CAAC,MAAM,OAAO,sBAAsB,EAAE"}

package/dist/node/node_modules/.pnpm/drizzle-orm@0.44.7_@electric-sql_pglite@0.3.15_@libsql_client@0.14.0_@prisma_client@6.1_945233f0b9a56e69a65134d4c5811e1b/node_modules/drizzle-orm/pg-core/unique-constraint.js

@@ -0,0 +1,56 @@
+import { entityKind } from "../entity.js";
+import { TableName } from "../table.utils.js";
+
+//#region ../../node_modules/.pnpm/drizzle-orm@0.44.7_@electric-sql+pglite@0.3.15_@libsql+client@0.14.0_@prisma+client@6.1_945233f0b9a56e69a65134d4c5811e1b/node_modules/drizzle-orm/pg-core/unique-constraint.js
+function uniqueKeyName(table, columns) {
+	return `${table[TableName]}_${columns.join("_")}_unique`;
+}
+var UniqueConstraintBuilder = class {
+	constructor(columns, name) {
+		this.name = name;
+		this.columns = columns;
+	}
+	static [entityKind] = "PgUniqueConstraintBuilder";
+	/** @internal */
+	columns;
+	/** @internal */
+	nullsNotDistinctConfig = false;
+	nullsNotDistinct() {
+		this.nullsNotDistinctConfig = true;
+		return this;
+	}
+	/** @internal */
+	build(table) {
+		return new UniqueConstraint(table, this.columns, this.nullsNotDistinctConfig, this.name);
+	}
+};
+var UniqueOnConstraintBuilder = class {
+	static [entityKind] = "PgUniqueOnConstraintBuilder";
+	/** @internal */
+	name;
+	constructor(name) {
+		this.name = name;
+	}
+	on(...columns) {
+		return new UniqueConstraintBuilder(columns, this.name);
+	}
+};
+var UniqueConstraint = class {
+	constructor(table, columns, nullsNotDistinct, name) {
+		this.table = table;
+		this.columns = columns;
+		this.name = name ?? uniqueKeyName(this.table, this.columns.map((column) => column.name));
+		this.nullsNotDistinct = nullsNotDistinct;
+	}
+	static [entityKind] = "PgUniqueConstraint";
+	columns;
+	name;
+	nullsNotDistinct = false;
+	getName() {
+		return this.name;
+	}
+};
+
+//#endregion
+export { uniqueKeyName };
+//# sourceMappingURL=unique-constraint.js.map

package/dist/node/node_modules/.pnpm/drizzle-orm@0.44.7_@electric-sql_pglite@0.3.15_@libsql_client@0.14.0_@prisma_client@6.1_945233f0b9a56e69a65134d4c5811e1b/node_modules/drizzle-orm/pg-core/unique-constraint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unique-constraint.js","names":[],"sources":["../../../../../../../../../../node_modules/.pnpm/drizzle-orm@0.44.7_@electric-sql+pglite@0.3.15_@libsql+client@0.14.0_@prisma+client@6.1_945233f0b9a56e69a65134d4c5811e1b/node_modules/drizzle-orm/pg-core/unique-constraint.js"],"sourcesContent":["import { entityKind } from \"../entity.js\";\nimport { TableName } from \"../table.utils.js\";\nfunction unique(name) {\n  return new UniqueOnConstraintBuilder(name);\n}\nfunction uniqueKeyName(table, columns) {\n  return `${table[TableName]}_${columns.join(\"_\")}_unique`;\n}\nclass UniqueConstraintBuilder {\n  constructor(columns, name) {\n    this.name = name;\n    this.columns = columns;\n  }\n  static [entityKind] = \"PgUniqueConstraintBuilder\";\n  /** @internal */\n  columns;\n  /** @internal */\n  nullsNotDistinctConfig = false;\n  nullsNotDistinct() {\n    this.nullsNotDistinctConfig = true;\n    return this;\n  }\n  /** @internal */\n  build(table) {\n    return new UniqueConstraint(table, this.columns, this.nullsNotDistinctConfig, this.name);\n  }\n}\nclass UniqueOnConstraintBuilder {\n  static [entityKind] = \"PgUniqueOnConstraintBuilder\";\n  /** @internal */\n  name;\n  constructor(name) {\n    this.name = name;\n  }\n  on(...columns) {\n    return new UniqueConstraintBuilder(columns, this.name);\n  }\n}\nclass UniqueConstraint {\n  constructor(table, columns, nullsNotDistinct, name) {\n    this.table = table;\n    this.columns = columns;\n    this.name = name ?? uniqueKeyName(this.table, this.columns.map((column) => column.name));\n    this.nullsNotDistinct = nullsNotDistinct;\n  }\n  static [entityKind] = \"PgUniqueConstraint\";\n  columns;\n  name;\n  nullsNotDistinct = false;\n  getName() {\n    return this.name;\n  }\n}\nexport {\n  UniqueConstraint,\n  UniqueConstraintBuilder,\n  UniqueOnConstraintBuilder,\n  unique,\n  uniqueKeyName\n};\n//# sourceMappingURL=unique-constraint.js.map"],"x_google_ignoreList":[0],"mappings":";;;;AAKA,SAAS,cAAc,OAAO,SAAS;AACrC,QAAO,GAAG,MAAM,WAAW,GAAG,QAAQ,KAAK,IAAI,CAAC;;AAElD,IAAM,0BAAN,MAA8B;CAC5B,YAAY,SAAS,MAAM;AACzB,OAAK,OAAO;AACZ,OAAK,UAAU;;CAEjB,QAAQ,cAAc;;CAEtB;;CAEA,yBAAyB;CACzB,mBAAmB;AACjB,OAAK,yBAAyB;AAC9B,SAAO;;;CAGT,MAAM,OAAO;AACX,SAAO,IAAI,iBAAiB,OAAO,KAAK,SAAS,KAAK,wBAAwB,KAAK,KAAK;;;AAG5F,IAAM,4BAAN,MAAgC;CAC9B,QAAQ,cAAc;;CAEtB;CACA,YAAY,MAAM;AAChB,OAAK,OAAO;;CAEd,GAAG,GAAG,SAAS;AACb,SAAO,IAAI,wBAAwB,SAAS,KAAK,KAAK;;;AAG1D,IAAM,mBAAN,MAAuB;CACrB,YAAY,OAAO,SAAS,kBAAkB,MAAM;AAClD,OAAK,QAAQ;AACb,OAAK,UAAU;AACf,OAAK,OAAO,QAAQ,cAAc,KAAK,OAAO,KAAK,QAAQ,KAAK,WAAW,OAAO,KAAK,CAAC;AACxF,OAAK,mBAAmB;;CAE1B,QAAQ,cAAc;CACtB;CACA;CACA,mBAAmB;CACnB,UAAU;AACR,SAAO,KAAK"}

package/dist/node/node_modules/.pnpm/drizzle-orm@0.44.7_@electric-sql_pglite@0.3.15_@libsql_client@0.14.0_@prisma_client@6.1_945233f0b9a56e69a65134d4c5811e1b/node_modules/drizzle-orm/pg-core/utils/array.js

@@ -0,0 +1,65 @@
+//#region ../../node_modules/.pnpm/drizzle-orm@0.44.7_@electric-sql+pglite@0.3.15_@libsql+client@0.14.0_@prisma+client@6.1_945233f0b9a56e69a65134d4c5811e1b/node_modules/drizzle-orm/pg-core/utils/array.js
+function parsePgArrayValue(arrayString, startFrom, inQuotes) {
+	for (let i = startFrom; i < arrayString.length; i++) {
+		const char = arrayString[i];
+		if (char === "\\") {
+			i++;
+			continue;
+		}
+		if (char === "\"") return [arrayString.slice(startFrom, i).replace(/\\/g, ""), i + 1];
+		if (inQuotes) continue;
+		if (char === "," || char === "}") return [arrayString.slice(startFrom, i).replace(/\\/g, ""), i];
+	}
+	return [arrayString.slice(startFrom).replace(/\\/g, ""), arrayString.length];
+}
+function parsePgNestedArray(arrayString, startFrom = 0) {
+	const result = [];
+	let i = startFrom;
+	let lastCharIsComma = false;
+	while (i < arrayString.length) {
+		const char = arrayString[i];
+		if (char === ",") {
+			if (lastCharIsComma || i === startFrom) result.push("");
+			lastCharIsComma = true;
+			i++;
+			continue;
+		}
+		lastCharIsComma = false;
+		if (char === "\\") {
+			i += 2;
+			continue;
+		}
+		if (char === "\"") {
+			const [value2, startFrom2] = parsePgArrayValue(arrayString, i + 1, true);
+			result.push(value2);
+			i = startFrom2;
+			continue;
+		}
+		if (char === "}") return [result, i + 1];
+		if (char === "{") {
+			const [value2, startFrom2] = parsePgNestedArray(arrayString, i + 1);
+			result.push(value2);
+			i = startFrom2;
+			continue;
+		}
+		const [value, newStartFrom] = parsePgArrayValue(arrayString, i, false);
+		result.push(value);
+		i = newStartFrom;
+	}
+	return [result, i];
+}
+function parsePgArray(arrayString) {
+	const [result] = parsePgNestedArray(arrayString, 1);
+	return result;
+}
+function makePgArray(array) {
+	return `{${array.map((item) => {
+		if (Array.isArray(item)) return makePgArray(item);
+		if (typeof item === "string") return `"${item.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+		return `${item}`;
+	}).join(",")}}`;
+}
+
+//#endregion
+export { makePgArray, parsePgArray };
+//# sourceMappingURL=array.js.map

package/dist/node/node_modules/.pnpm/drizzle-orm@0.44.7_@electric-sql_pglite@0.3.15_@libsql_client@0.14.0_@prisma_client@6.1_945233f0b9a56e69a65134d4c5811e1b/node_modules/drizzle-orm/pg-core/utils/array.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.js","names":[],"sources":["../../../../../../../../../../../node_modules/.pnpm/drizzle-orm@0.44.7_@electric-sql+pglite@0.3.15_@libsql+client@0.14.0_@prisma+client@6.1_945233f0b9a56e69a65134d4c5811e1b/node_modules/drizzle-orm/pg-core/utils/array.js"],"sourcesContent":["function parsePgArrayValue(arrayString, startFrom, inQuotes) {\n  for (let i = startFrom; i < arrayString.length; i++) {\n    const char = arrayString[i];\n    if (char === \"\\\\\") {\n      i++;\n      continue;\n    }\n    if (char === '\"') {\n      return [arrayString.slice(startFrom, i).replace(/\\\\/g, \"\"), i + 1];\n    }\n    if (inQuotes) {\n      continue;\n    }\n    if (char === \",\" || char === \"}\") {\n      return [arrayString.slice(startFrom, i).replace(/\\\\/g, \"\"), i];\n    }\n  }\n  return [arrayString.slice(startFrom).replace(/\\\\/g, \"\"), arrayString.length];\n}\nfunction parsePgNestedArray(arrayString, startFrom = 0) {\n  const result = [];\n  let i = startFrom;\n  let lastCharIsComma = false;\n  while (i < arrayString.length) {\n    const char = arrayString[i];\n    if (char === \",\") {\n      if (lastCharIsComma || i === startFrom) {\n        result.push(\"\");\n      }\n      lastCharIsComma = true;\n      i++;\n      continue;\n    }\n    lastCharIsComma = false;\n    if (char === \"\\\\\") {\n      i += 2;\n      continue;\n    }\n    if (char === '\"') {\n      const [value2, startFrom2] = parsePgArrayValue(arrayString, i + 1, true);\n      result.push(value2);\n      i = startFrom2;\n      continue;\n    }\n    if (char === \"}\") {\n      return [result, i + 1];\n    }\n    if (char === \"{\") {\n      const [value2, startFrom2] = parsePgNestedArray(arrayString, i + 1);\n      result.push(value2);\n      i = startFrom2;\n      continue;\n    }\n    const [value, newStartFrom] = parsePgArrayValue(arrayString, i, false);\n    result.push(value);\n    i = newStartFrom;\n  }\n  return [result, i];\n}\nfunction parsePgArray(arrayString) {\n  const [result] = parsePgNestedArray(arrayString, 1);\n  return result;\n}\nfunction makePgArray(array) {\n  return `{${array.map((item) => {\n    if (Array.isArray(item)) {\n      return makePgArray(item);\n    }\n    if (typeof item === \"string\") {\n      return `\"${item.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"')}\"`;\n    }\n    return `${item}`;\n  }).join(\",\")}}`;\n}\nexport {\n  makePgArray,\n  parsePgArray,\n  parsePgNestedArray\n};\n//# sourceMappingURL=array.js.map"],"x_google_ignoreList":[0],"mappings":";AAAA,SAAS,kBAAkB,aAAa,WAAW,UAAU;AAC3D,MAAK,IAAI,IAAI,WAAW,IAAI,YAAY,QAAQ,KAAK;EACnD,MAAM,OAAO,YAAY;AACzB,MAAI,SAAS,MAAM;AACjB;AACA;;AAEF,MAAI,SAAS,KACX,QAAO,CAAC,YAAY,MAAM,WAAW,EAAE,CAAC,QAAQ,OAAO,GAAG,EAAE,IAAI,EAAE;AAEpE,MAAI,SACF;AAEF,MAAI,SAAS,OAAO,SAAS,IAC3B,QAAO,CAAC,YAAY,MAAM,WAAW,EAAE,CAAC,QAAQ,OAAO,GAAG,EAAE,EAAE;;AAGlE,QAAO,CAAC,YAAY,MAAM,UAAU,CAAC,QAAQ,OAAO,GAAG,EAAE,YAAY,OAAO;;AAE9E,SAAS,mBAAmB,aAAa,YAAY,GAAG;CACtD,MAAM,SAAS,EAAE;CACjB,IAAI,IAAI;CACR,IAAI,kBAAkB;AACtB,QAAO,IAAI,YAAY,QAAQ;EAC7B,MAAM,OAAO,YAAY;AACzB,MAAI,SAAS,KAAK;AAChB,OAAI,mBAAmB,MAAM,UAC3B,QAAO,KAAK,GAAG;AAEjB,qBAAkB;AAClB;AACA;;AAEF,oBAAkB;AAClB,MAAI,SAAS,MAAM;AACjB,QAAK;AACL;;AAEF,MAAI,SAAS,MAAK;GAChB,MAAM,CAAC,QAAQ,cAAc,kBAAkB,aAAa,IAAI,GAAG,KAAK;AACxE,UAAO,KAAK,OAAO;AACnB,OAAI;AACJ;;AAEF,MAAI,SAAS,IACX,QAAO,CAAC,QAAQ,IAAI,EAAE;AAExB,MAAI,SAAS,KAAK;GAChB,MAAM,CAAC,QAAQ,cAAc,mBAAmB,aAAa,IAAI,EAAE;AACnE,UAAO,KAAK,OAAO;AACnB,OAAI;AACJ;;EAEF,MAAM,CAAC,OAAO,gBAAgB,kBAAkB,aAAa,GAAG,MAAM;AACtE,SAAO,KAAK,MAAM;AAClB,MAAI;;AAEN,QAAO,CAAC,QAAQ,EAAE;;AAEpB,SAAS,aAAa,aAAa;CACjC,MAAM,CAAC,UAAU,mBAAmB,aAAa,EAAE;AACnD,QAAO;;AAET,SAAS,YAAY,OAAO;AAC1B,QAAO,IAAI,MAAM,KAAK,SAAS;AAC7B,MAAI,MAAM,QAAQ,KAAK,CACrB,QAAO,YAAY,KAAK;AAE1B,MAAI,OAAO,SAAS,SAClB,QAAO,IAAI,KAAK,QAAQ,OAAO,OAAO,CAAC,QAAQ,MAAM,OAAM,CAAC;AAE9D,SAAO,GAAG;GACV,CAAC,KAAK,IAAI,CAAC"}