@geekmidas/db 10.0.0-alpha.99 → 10.0.0

package/src/objection/__tests__/pagination.integration.spec.ts

@@ -0,0 +1,291 @@
+import knex, { type Knex } from 'knex';
+import { Model } from 'objection';
+import {
+	afterAll,
+	afterEach,
+	beforeAll,
+	beforeEach,
+	describe,
+	expect,
+	it,
+} from 'vitest';
+import { TEST_DATABASE_CONFIG } from '../../../../testkit/test/globalSetup';
+import { Direction, paginatedSearch } from '../pagination';
+
+class PaginationTestItem extends Model {
+	static tableName = 'objection_pagination_test_items';
+
+	id!: number;
+	name!: string;
+	category!: string;
+	price!: number;
+	createdAt!: Date;
+}
+
+describe('Objection Pagination Integration Tests', () => {
+	let db: Knex;
+
+	beforeAll(async () => {
+		db = knex({
+			client: 'pg',
+			connection: {
+				...TEST_DATABASE_CONFIG,
+				database: 'postgres',
+			},
+		});
+
+		Model.knex(db);
+
+		await db.schema.createTableIfNotExists(
+			'objection_pagination_test_items',
+			(table) => {
+				table.increments('id').primary();
+				table.string('name', 255).notNullable();
+				table.string('category', 100).notNullable();
+				table.decimal('price', 10, 2).notNullable();
+				table.timestamp('created_at').defaultTo(db.fn.now()).notNullable();
+			},
+		);
+	});
+
+	beforeEach(async () => {
+		const items = [];
+		for (let i = 1; i <= 25; i++) {
+			items.push({
+				name: `Item ${String(i).padStart(2, '0')}`,
+				category:
+					i <= 10 ? 'category-a' : i <= 20 ? 'category-b' : 'category-c',
+				price: i * 10,
+			});
+		}
+		await PaginationTestItem.query().insert(items);
+	});
+
+	afterEach(async () => {
+		await PaginationTestItem.query().delete();
+	});
+
+	afterAll(async () => {
+		await db.schema.dropTableIfExists('objection_pagination_test_items');
+		await db.destroy();
+	});
+
+	describe('paginatedSearch', () => {
+		it('should return first page of results with default settings', async () => {
+			const result = await paginatedSearch({
+				query: PaginationTestItem.query(),
+				limit: 10,
+			});
+
+			expect(result.items).toHaveLength(10);
+			expect(result.pagination.total).toBe(25);
+			expect(result.pagination.hasMore).toBe(true);
+			expect(result.pagination.cursor).toBeDefined();
+		});
+
+		it('should return model instances when no mapRow is provided', async () => {
+			const result = await paginatedSearch({
+				query: PaginationTestItem.query(),
+				limit: 5,
+			});
+
+			expect(result.items[0]).toBeInstanceOf(PaginationTestItem);
+			expect(result.items[0].name).toBeDefined();
+		});
+
+		it('should return second page using cursor', async () => {
+			const firstPage = await paginatedSearch({
+				query: PaginationTestItem.query(),
+				limit: 10,
+				cursorDirection: Direction.Asc,
+			});
+
+			expect(firstPage.pagination.cursor).toBeDefined();
+
+			const secondPage = await paginatedSearch({
+				query: PaginationTestItem.query(),
+				cursor: firstPage.pagination.cursor,
+				limit: 10,
+				cursorDirection: Direction.Asc,
+			});
+
+			expect(secondPage.items).toHaveLength(10);
+			expect(secondPage.pagination.total).toBe(25);
+			expect(secondPage.pagination.hasMore).toBe(true);
+
+			const firstIds = firstPage.items.map((i) => i.id);
+			const secondIds = secondPage.items.map((i) => i.id);
+			expect(firstIds.every((id) => !secondIds.includes(id))).toBe(true);
+		});
+
+		it('should return last page with hasMore false', async () => {
+			let cursor: string | undefined;
+			const pages: PaginationTestItem[][] = [];
+
+			do {
+				const page = await paginatedSearch({
+					query: PaginationTestItem.query(),
+					cursor,
+					limit: 10,
+					cursorDirection: Direction.Asc,
+				});
+
+				pages.push(page.items);
+				cursor = page.pagination.cursor;
+
+				if (!page.pagination.hasMore) break;
+			} while (cursor);
+
+			expect(pages).toHaveLength(3);
+			expect(pages[0]).toHaveLength(10);
+			expect(pages[1]).toHaveLength(10);
+			expect(pages[2]).toHaveLength(5);
+
+			const allItems = pages.flat();
+			expect(allItems).toHaveLength(25);
+		});
+
+		it('should paginate in descending order', async () => {
+			const result = await paginatedSearch({
+				query: PaginationTestItem.query(),
+				limit: 5,
+				cursorDirection: Direction.Desc,
+			});
+
+			const ids = result.items.map((i) => i.id);
+			for (let i = 1; i < ids.length; i++) {
+				expect(ids[i]).toBeLessThan(ids[i - 1]);
+			}
+
+			const secondPage = await paginatedSearch({
+				query: PaginationTestItem.query(),
+				cursor: result.pagination.cursor,
+				limit: 5,
+				cursorDirection: Direction.Desc,
+			});
+
+			const maxSecondPage = Math.max(...secondPage.items.map((i) => i.id));
+			const minFirstPage = Math.min(...ids);
+			expect(maxSecondPage).toBeLessThan(minFirstPage);
+		});
+
+		it('should work with custom cursor field', async () => {
+			const result = await paginatedSearch({
+				query: PaginationTestItem.query(),
+				limit: 5,
+				mapRow: (row) => ({ id: row.id, name: row.name, price: row.price }),
+				cursorField: 'price',
+				cursorDirection: Direction.Asc,
+			});
+
+			const prices = result.items.map((i) => Number(i.price));
+			for (let i = 1; i < prices.length; i++) {
+				expect(prices[i]).toBeGreaterThan(prices[i - 1]);
+			}
+
+			expect(Number(result.pagination.cursor)).toBe(prices[prices.length - 1]);
+
+			const secondPage = await paginatedSearch({
+				query: PaginationTestItem.query(),
+				cursor: result.pagination.cursor,
+				limit: 5,
+				mapRow: (row) => ({ id: row.id, name: row.name, price: row.price }),
+				cursorField: 'price',
+				cursorDirection: Direction.Asc,
+			});
+
+			const minSecondPage = Math.min(
+				...secondPage.items.map((i) => Number(i.price)),
+			);
+			expect(minSecondPage).toBeGreaterThan(prices[prices.length - 1]);
+		});
+
+		it('should use default limit of 20', async () => {
+			const result = await paginatedSearch({
+				query: PaginationTestItem.query(),
+			});
+
+			expect(result.items).toHaveLength(20);
+		});
+
+		it('should work with filtered queries', async () => {
+			const result = await paginatedSearch({
+				query: PaginationTestItem.query().where('category', 'category-a'),
+				limit: 5,
+				mapRow: (row) => ({
+					id: row.id,
+					name: row.name,
+					category: row.category,
+				}),
+			});
+
+			expect(result.pagination.total).toBe(10);
+			expect(result.items).toHaveLength(5);
+			for (const item of result.items) {
+				expect(item.category).toBe('category-a');
+			}
+		});
+
+		it('should handle empty result set', async () => {
+			const result = await paginatedSearch({
+				query: PaginationTestItem.query().where('category', 'nonexistent'),
+				limit: 10,
+			});
+
+			expect(result.items).toHaveLength(0);
+			expect(result.pagination.total).toBe(0);
+			expect(result.pagination.hasMore).toBe(false);
+			expect(result.pagination.cursor).toBeUndefined();
+		});
+
+		it('should work with mapRow transformation', async () => {
+			const result = await paginatedSearch({
+				query: PaginationTestItem.query(),
+				limit: 5,
+				mapRow: (row) => ({
+					id: row.id,
+					displayName: `Product: ${row.name}`,
+					priceFormatted: `$${Number(row.price).toFixed(2)}`,
+				}),
+			});
+
+			expect(result.items).toHaveLength(5);
+			for (const item of result.items) {
+				expect(item.displayName).toMatch(/^Product: Item \d+$/);
+				expect(item.priceFormatted).toMatch(/^\$\d+\.\d{2}$/);
+			}
+		});
+
+		it('should work with eager loading', async () => {
+			// withGraphFetched doesn't error even without relations defined;
+			// this validates the query builder composition works end-to-end
+			const result = await paginatedSearch({
+				query: PaginationTestItem.query().select('id', 'name'),
+				limit: 5,
+			});
+
+			expect(result.items).toHaveLength(5);
+			expect(result.items[0].id).toBeDefined();
+			expect(result.items[0].name).toBeDefined();
+		});
+
+		it('should work with async mapRow function', async () => {
+			const result = await paginatedSearch({
+				query: PaginationTestItem.query(),
+				limit: 5,
+				mapRow: async (row) => {
+					await new Promise((resolve) => setTimeout(resolve, 1));
+					return {
+						id: row.id,
+						displayName: `Product: ${row.name}`,
+					};
+				},
+			});
+
+			expect(result.items).toHaveLength(5);
+			for (const item of result.items) {
+				expect(item.displayName).toMatch(/^Product: Item \d+$/);
+			}
+		});
+	});
+});

package/src/objection/pagination.ts

@@ -0,0 +1,98 @@
+import type { Model, QueryBuilder } from 'objection';
+import {
+	Direction,
+	decodeCursor,
+	encodeCursor,
+	type PaginationResult,
+} from '../pagination';
+
+export { Direction, decodeCursor, encodeCursor, type PaginationResult };
+
+/**
+ * Options for paginated search with Objection.js models.
+ */
+export interface ObjectionPaginatedSearchOptions<
+	TModel extends Model,
+	TMapRow extends (row: TModel) => unknown = (row: TModel) => TModel,
+> {
+	/** The Objection QueryBuilder to paginate (e.g. User.query(trx).where(...)) */
+	query: QueryBuilder<TModel>;
+	/** Cursor value for pagination (value of cursorField from previous page) */
+	cursor?: string;
+	/** Maximum number of items per page (default: 20) */
+	limit?: number;
+	/** Function to transform each row to the output format (default: identity) */
+	mapRow?: TMapRow;
+	/** Field to use for cursor pagination (default: 'id') */
+	cursorField?: string;
+	/** Sort direction for cursor field (default: Direction.Asc) */
+	cursorDirection?: Direction;
+}
+
+/**
+ * Cursor-based paginated search for Objection.js models.
+ *
+ * Accepts a pre-built QueryBuilder so callers can apply filters,
+ * eager loading, and scopes before pagination is layered on top.
+ *
+ * @example
+ * ```typescript
+ * const result = await paginatedSearch({
+ *   query: User.query(trx).where('orgId', orgId).withGraphFetched('roles'),
+ *   cursor: previousCursor,
+ *   limit: 20,
+ *   cursorField: 'createdAt',
+ *   cursorDirection: Direction.Desc,
+ * });
+ * ```
+ */
+export async function paginatedSearch<
+	TModel extends Model,
+	TMapRow extends (row: TModel) => unknown = (row: TModel) => TModel,
+>({
+	query,
+	cursor,
+	limit = 20,
+	mapRow,
+	cursorField = 'id',
+	cursorDirection = Direction.Asc,
+}: ObjectionPaginatedSearchOptions<TModel, TMapRow>): Promise<
+	PaginationResult<Awaited<ReturnType<TMapRow>>>
+> {
+	// Get total count (without cursor filtering)
+	const total = await query.resultSize();
+
+	// Apply cursor if provided
+	let paginatedQuery = query.clone();
+	if (cursor) {
+		const operator = cursorDirection === Direction.Asc ? '>' : '<';
+		paginatedQuery = paginatedQuery.where(cursorField, operator, cursor);
+	}
+
+	// Fetch one extra to determine if there are more results
+	const data = await paginatedQuery
+		.orderBy(cursorField, cursorDirection)
+		.limit(limit + 1);
+
+	const hasMore = data.length > limit;
+	const rows = hasMore ? data.slice(0, limit) : data;
+	const lastRow = rows[rows.length - 1];
+	const nextCursor =
+		hasMore && lastRow
+			? String((lastRow as Record<string, unknown>)[cursorField])
+			: undefined;
+
+	const mapper = mapRow ?? ((row: TModel) => row);
+	const items = (await Promise.all(rows.map(mapper))) as Awaited<
+		ReturnType<TMapRow>
+	>[];
+
+	return {
+		items,
+		pagination: {
+			total,
+			hasMore,
+			cursor: nextCursor,
+		},
+	};
+}

package/src/pagination.ts

@@ -0,0 +1,49 @@
+/**
+ * Sort direction for cursor-based pagination.
+ */
+export enum Direction {
+	Asc = 'asc',
+	Desc = 'desc',
+}
+
+/**
+ * Result of a paginated query.
+ */
+export interface PaginationResult<TItem> {
+	items: TItem[];
+	pagination: {
+		total: number;
+		hasMore: boolean;
+		cursor?: string;
+	};
+}
+
+/**
+ * Encode a cursor value for safe URL transmission.
+ * Supports various types: string, number, Date, etc.
+ */
+export function encodeCursor(value: unknown): string {
+	const payload = {
+		v: value instanceof Date ? value.toISOString() : value,
+		t: value instanceof Date ? 'date' : typeof value,
+	};
+	return Buffer.from(JSON.stringify(payload)).toString('base64url');
+}
+
+/**
+ * Decode a cursor string back to its original value.
+ */
+export function decodeCursor(cursor: string): unknown {
+	try {
+		const json = Buffer.from(cursor, 'base64url').toString('utf-8');
+		const payload = JSON.parse(json);
+
+		if (payload.t === 'date') {
+			return new Date(payload.v);
+		}
+
+		return payload.v;
+	} catch {
+		throw new Error('Invalid cursor format');
+	}
+}

package/src/rls.ts

@@ -0,0 +1,90 @@
+import type { Transaction } from 'kysely';
+import { sql } from 'kysely';
+import {
+	type DatabaseConnection,
+	type TransactionSettings,
+	withTransaction,
+} from './kysely';
+
+/**
+ * RLS context - key-value pairs to set as PostgreSQL session variables.
+ * Keys become `prefix.key` (e.g., `app.user_id`).
+ */
+export interface RlsContext {
+	[key: string]: string | number | boolean | null | undefined;
+}
+
+/**
+ * Options for withRlsContext function.
+ */
+export interface WithRlsContextOptions {
+	/** Prefix for PostgreSQL session variables (default: 'app') */
+	prefix?: string;
+	/** Transaction settings (isolation level) */
+	settings?: TransactionSettings;
+}
+
+/**
+ * Execute a callback within a transaction with RLS context variables set.
+ *
+ * Sets PostgreSQL session variables using `SET LOCAL` which scopes them to the
+ * current transaction. Variables are automatically cleared when the transaction
+ * ends (commit or rollback).
+ *
+ * @example
+ * ```ts
+ * await withRlsContext(
+ *   db,
+ *   { user_id: session.userId, tenant_id: session.tenantId },
+ *   async (trx) => {
+ *     // RLS policies can now use current_setting('app.user_id')
+ *     return trx.selectFrom('orders').selectAll().execute();
+ *   }
+ * );
+ * ```
+ *
+ * @param db - Database connection (Kysely, Transaction, or ControlledTransaction)
+ * @param context - Key-value pairs to set as session variables
+ * @param callback - Function to execute within the RLS context
+ * @param options - Optional prefix and transaction settings
+ */
+export async function withRlsContext<DB, T>(
+	db: DatabaseConnection<DB>,
+	context: RlsContext,
+	callback: (trx: Transaction<DB>) => Promise<T>,
+	options?: WithRlsContextOptions,
+): Promise<T> {
+	const prefix = options?.prefix ?? 'app';
+
+	return withTransaction(
+		db,
+		async (trx) => {
+			// Set each context variable using SET LOCAL (scoped to transaction)
+			for (const [key, value] of Object.entries(context)) {
+				if (value === null || value === undefined) continue;
+
+				const settingName = `${prefix}.${key}`;
+				const settingValue = String(value);
+
+				// Use raw SQL for SET LOCAL with proper escaping
+				// The setting name is an identifier, value is a string literal
+				await sql`SELECT set_config(${settingName}, ${settingValue}, true)`.execute(
+					trx,
+				);
+			}
+
+			return callback(trx);
+		},
+		options?.settings,
+	);
+}
+
+/**
+ * Bypass marker symbol for explicitly skipping RLS context.
+ */
+export const RLS_BYPASS = Symbol.for('geekmidas.rls.bypass');
+
+/**
+ * Type for RLS bypass marker.
+ */
+export type RlsBypass = typeof RLS_BYPASS;

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "composite": true
+  },
+  "include": ["src/**/*"]
+}

package/dist/errors.cjs

@@ -1,73 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-//#region src/errors.ts
-/**
-* Database URL errors and redaction — engine-neutral.
-*
-* Nothing here is Postgres-specific: every engine addresses itself as a URL
-* carrying a password, and "must name a host" holds for all of them. The parts
-* that differ — libpq's `options=-c search_path=…`, which no other engine
-* accepts — live under the driver they belong to.
-*
-* Messages state the rule, which is constant; the offending value is a field.
-* An interpolated message cannot be matched on and carries user input into
-* every log line that touches it.
-*/
-/**
-* Replace the password in a connection string with `***`.
-*
-* A connection string is a secret, and the places it is most likely to be
-* written down — a log line, an error, a crash report shipped to a third party
-* — are the places nobody is reading carefully. This exists so that redacting
-* is the easy thing to do at each of them.
-*
-* Safe on input that is not a URL: it returns a constant rather than throwing,
-* because this runs on paths that must not fail. Anything unparseable is
-* treated as potentially secret and withheld entirely rather than echoed.
-*/
-function redactDatabaseUrl(url) {
-	try {
-		const parsed = new URL(url);
-		if (!parsed.password) return url;
-		parsed.password = "***";
-		return parsed.toString();
-	} catch {
-		return "<unparseable url>";
-	}
-}
-/**
-* Base for an address that cannot become a connection string.
-*
-* Deliberately carries no URL field: these are thrown while *composing* one, so
-* there is no URL yet — only the parts, which include the password.
-*/
-var DatabaseAddressError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = new.target.name;
-	}
-};
-/** An address with no host to connect to. */
-var MissingDatabaseHost = class extends DatabaseAddressError {
-	constructor() {
-		super("A database address must name a host");
-	}
-};
-/**
-* An address with no database name.
-*
-* Postgres silently falls back to the connecting role's name, so the app
-* connects successfully to the wrong database and fails later with confusing
-* "relation does not exist" errors. Rejecting it here is much cheaper.
-*/
-var MissingDatabaseName = class extends DatabaseAddressError {
-	constructor() {
-		super("A database address must name a database");
-	}
-};
-//#endregion
-exports.DatabaseAddressError = DatabaseAddressError;
-exports.MissingDatabaseHost = MissingDatabaseHost;
-exports.MissingDatabaseName = MissingDatabaseName;
-exports.redactDatabaseUrl = redactDatabaseUrl;
-
-//# sourceMappingURL=errors.cjs.map

package/dist/errors.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.cjs","names":[],"sources":["../src/errors.ts"],"sourcesContent":["/**\n * Database URL errors and redaction — engine-neutral.\n *\n * Nothing here is Postgres-specific: every engine addresses itself as a URL\n * carrying a password, and \"must name a host\" holds for all of them. The parts\n * that differ — libpq's `options=-c search_path=…`, which no other engine\n * accepts — live under the driver they belong to.\n *\n * Messages state the rule, which is constant; the offending value is a field.\n * An interpolated message cannot be matched on and carries user input into\n * every log line that touches it.\n */\n\n/**\n * Replace the password in a connection string with `***`.\n *\n * A connection string is a secret, and the places it is most likely to be\n * written down — a log line, an error, a crash report shipped to a third party\n * — are the places nobody is reading carefully. This exists so that redacting\n * is the easy thing to do at each of them.\n *\n * Safe on input that is not a URL: it returns a constant rather than throwing,\n * because this runs on paths that must not fail. Anything unparseable is\n * treated as potentially secret and withheld entirely rather than echoed.\n */\nexport function redactDatabaseUrl(url: string): string {\n\ttry {\n\t\tconst parsed = new URL(url);\n\t\tif (!parsed.password) return url;\n\t\tparsed.password = '***';\n\t\treturn parsed.toString();\n\t} catch {\n\t\treturn '<unparseable url>';\n\t}\n}\n\n/**\n * Base for an address that cannot become a connection string.\n *\n * Deliberately carries no URL field: these are thrown while *composing* one, so\n * there is no URL yet — only the parts, which include the password.\n */\nexport abstract class DatabaseAddressError extends Error {\n\tconstructor(message: string) {\n\t\tsuper(message);\n\t\tthis.name = new.target.name;\n\t}\n}\n\n/** An address with no host to connect to. */\nexport class MissingDatabaseHost extends DatabaseAddressError {\n\tconstructor() {\n\t\tsuper('A database address must name a host');\n\t}\n}\n\n/**\n * An address with no database name.\n *\n * Postgres silently falls back to the connecting role's name, so the app\n * connects successfully to the wrong database and fails later with confusing\n * \"relation does not exist\" errors. Rejecting it here is much cheaper.\n */\nexport class MissingDatabaseName extends DatabaseAddressError {\n\tconstructor() {\n\t\tsuper('A database address must name a database');\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,SAAgB,kBAAkB,KAAqB;CACtD,IAAI;EACH,MAAM,SAAS,IAAI,IAAI,GAAG;EAC1B,IAAI,CAAC,OAAO,UAAU,OAAO;EAC7B,OAAO,WAAW;EAClB,OAAO,OAAO,SAAS;CACxB,QAAQ;EACP,OAAO;CACR;AACD;;;;;;;AAQA,IAAsB,uBAAtB,cAAmD,MAAM;CACxD,YAAY,SAAiB;EAC5B,MAAM,OAAO;EACb,KAAK,OAAO,WAAW;CACxB;AACD;;AAGA,IAAa,sBAAb,cAAyC,qBAAqB;CAC7D,cAAc;EACb,MAAM,qCAAqC;CAC5C;AACD;;;;;;;;AASA,IAAa,sBAAb,cAAyC,qBAAqB;CAC7D,cAAc;EACb,MAAM,yCAAyC;CAChD;AACD"}

package/dist/errors.d.cts

@@ -1,51 +0,0 @@
-//#region src/errors.d.ts
-/**
- * Database URL errors and redaction — engine-neutral.
- *
- * Nothing here is Postgres-specific: every engine addresses itself as a URL
- * carrying a password, and "must name a host" holds for all of them. The parts
- * that differ — libpq's `options=-c search_path=…`, which no other engine
- * accepts — live under the driver they belong to.
- *
- * Messages state the rule, which is constant; the offending value is a field.
- * An interpolated message cannot be matched on and carries user input into
- * every log line that touches it.
- */
-/**
- * Replace the password in a connection string with `***`.
- *
- * A connection string is a secret, and the places it is most likely to be
- * written down — a log line, an error, a crash report shipped to a third party
- * — are the places nobody is reading carefully. This exists so that redacting
- * is the easy thing to do at each of them.
- *
- * Safe on input that is not a URL: it returns a constant rather than throwing,
- * because this runs on paths that must not fail. Anything unparseable is
- * treated as potentially secret and withheld entirely rather than echoed.
- */
-export declare function redactDatabaseUrl(url: string): string;
-/**
- * Base for an address that cannot become a connection string.
- *
- * Deliberately carries no URL field: these are thrown while *composing* one, so
- * there is no URL yet — only the parts, which include the password.
- */
-export declare abstract class DatabaseAddressError extends Error {
-  constructor(message: string);
-}
-/** An address with no host to connect to. */
-export declare class MissingDatabaseHost extends DatabaseAddressError {
-  constructor();
-}
-/**
- * An address with no database name.
- *
- * Postgres silently falls back to the connecting role's name, so the app
- * connects successfully to the wrong database and fails later with confusing
- * "relation does not exist" errors. Rejecting it here is much cheaper.
- */
-export declare class MissingDatabaseName extends DatabaseAddressError {
-  constructor();
-}
-//#endregion
-//# sourceMappingURL=errors.d.cts.map

package/dist/errors.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.cts","names":[],"sources":["../src/errors.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;wBAyBgB,kBAAkB;;;;;;;8BAiBZ,6BAA6B;EAClD,YAAY;;;qBAOA,4BAA4B;EACxC;;;;;;;;;qBAYY,4BAA4B;EACxC"}