@qulib/core 0.8.2 → 0.10.0

package/dist/recipes/auth.js

@@ -0,0 +1,156 @@
+/** Defaults from the proven NQ-2 data-testid convention. */
+const DEFAULTS = {
+    loginUrl: '/login',
+    usernameSelector: '[data-testid=login-email]',
+    passwordSelector: '[data-testid=login-password]',
+    submitSelector: '[data-testid=login-submit]',
+    successSelector: '[data-testid=dashboard-root]',
+};
+/**
+ * Generate NeutralScenarios for the auth recipe.
+ *
+ * Returns 3 scenarios:
+ *   1. Happy-path login → lands on dashboard (smoke gate)
+ *   2. Invalid-credentials → inline error message shown (negative gate)
+ *   3. Protected route redirects unauthenticated users to login (security gate)
+ *
+ * All selectors come from the proven NQ-2/CaseLoom patterns and are overridable
+ * via RecipeConfig, so the recipe works for any form-login app.
+ */
+export function buildAuthScenarios(config = {}) {
+    const loginUrl = config.loginUrl ?? DEFAULTS.loginUrl;
+    const usernameSelector = config.usernameSelector ?? DEFAULTS.usernameSelector;
+    const passwordSelector = config.passwordSelector ?? DEFAULTS.passwordSelector;
+    const submitSelector = config.submitSelector ?? DEFAULTS.submitSelector;
+    const successSelector = config.successSelector ?? DEFAULTS.successSelector;
+    return [
+        {
+            id: 'recipe-auth-happy-path',
+            title: 'User can log in with valid credentials',
+            description: 'Submitting valid credentials navigates to the authenticated dashboard',
+            targetPath: loginUrl,
+            steps: [
+                { action: 'navigate', target: loginUrl, description: 'Open the login page' },
+                {
+                    action: 'type',
+                    target: usernameSelector,
+                    value: 'user@example.test',
+                    description: 'Enter email address',
+                },
+                {
+                    action: 'type',
+                    target: passwordSelector,
+                    value: 'correct-horse',
+                    description: 'Enter password',
+                },
+                {
+                    action: 'click',
+                    target: submitSelector,
+                    description: 'Submit the login form',
+                },
+                {
+                    action: 'assert-visible',
+                    target: successSelector,
+                    description: 'Dashboard or success indicator is shown',
+                },
+            ],
+            tags: ['auth', 'smoke', 'recipe-auth'],
+            recommendations: [
+                {
+                    adapter: 'cypress-e2e',
+                    reason: 'Proven NQ-2 / CaseLoom pattern — cy.get + type/click/should',
+                    confidence: 'high',
+                },
+                {
+                    adapter: 'playwright',
+                    reason: 'Proven NQ-2 pattern — page.locator + fill/click/expect',
+                    confidence: 'high',
+                },
+            ],
+            sourceGapIds: ['recipe-auth'],
+        },
+        {
+            id: 'recipe-auth-invalid-credentials',
+            title: 'Invalid credentials show an inline error',
+            description: 'Submitting wrong credentials stays on the login page and shows an error message',
+            targetPath: loginUrl,
+            steps: [
+                { action: 'navigate', target: loginUrl, description: 'Open the login page' },
+                {
+                    action: 'type',
+                    target: usernameSelector,
+                    value: 'user@example.test',
+                    description: 'Enter email address',
+                },
+                {
+                    action: 'type',
+                    target: passwordSelector,
+                    value: 'wrong-password',
+                    description: 'Enter an incorrect password',
+                },
+                {
+                    action: 'click',
+                    target: submitSelector,
+                    description: 'Submit with wrong credentials',
+                },
+                {
+                    action: 'assert-text',
+                    target: '[data-testid=login-error]',
+                    value: 'Invalid',
+                    description: 'Inline error message is shown',
+                },
+                {
+                    action: 'assert-visible',
+                    target: submitSelector,
+                    description: 'Still on the login page (submit button visible)',
+                },
+            ],
+            tags: ['auth', 'negative', 'recipe-auth'],
+            recommendations: [
+                {
+                    adapter: 'cypress-e2e',
+                    reason: 'Proven NQ-2 negative path — assert-text on error element',
+                    confidence: 'high',
+                },
+                {
+                    adapter: 'playwright',
+                    reason: 'Proven NQ-2 negative path — toContainText on error element',
+                    confidence: 'high',
+                },
+            ],
+            sourceGapIds: ['recipe-auth'],
+        },
+        {
+            id: 'recipe-auth-protected-redirect',
+            title: 'Unauthenticated access to a protected route redirects to login',
+            description: 'Visiting a protected route without a session redirects to the login page — authentication guard is wired',
+            targetPath: '/dashboard',
+            steps: [
+                {
+                    action: 'navigate',
+                    target: '/dashboard',
+                    description: 'Navigate directly to a protected route',
+                },
+                {
+                    action: 'assert-visible',
+                    target: submitSelector,
+                    description: 'Login form submit button is visible — we were redirected to login',
+                },
+            ],
+            tags: ['auth', 'security', 'recipe-auth'],
+            recommendations: [
+                {
+                    adapter: 'cypress-e2e',
+                    reason: 'Guards a critical security property — protected routes must redirect',
+                    confidence: 'medium',
+                },
+                {
+                    adapter: 'playwright',
+                    reason: 'Guards a critical security property — protected routes must redirect',
+                    confidence: 'medium',
+                },
+            ],
+            sourceGapIds: ['recipe-auth'],
+        },
+    ];
+}

package/dist/recipes/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Recipe toolshed — reusable NeutralScenario builders.
+ *
+ * Each recipe module exports a build* function that returns NeutralScenario[].
+ * Recipes are merged (additive) into whatever scenarios the adapter already has;
+ * they never replace existing scenarios.
+ *
+ * Available recipes:
+ *   auth  — login / logout / protected-route flows
+ *   a11y  — accessibility checks (landmark/heading/aria/title)
+ *   nav   — deep-link / browser-back / 404-handling
+ *   seed  — data-seeding and state-reset helpers
+ */
+import type { RecipeId, RecipeConfig } from '../schemas/recipe.schema.js';
+import type { NeutralScenario } from '../schemas/gap-analysis.schema.js';
+export { buildAuthScenarios } from './auth.js';
+export { buildA11yScenarios } from './a11y.js';
+export { buildNavScenarios } from './nav.js';
+export { buildSeedScenarios } from './seed.js';
+/**
+ * Expand a list of RecipeIds into their NeutralScenario arrays, applying
+ * optional per-recipe config. Returns an empty array when ids is empty or
+ * undefined — safe to call unconditionally.
+ */
+export declare function expandRecipes(ids: RecipeId[] | undefined, config?: RecipeConfig): NeutralScenario[];
+//# sourceMappingURL=index.d.ts.map

package/dist/recipes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/recipes/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC1E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAMzE,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAE/C;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,QAAQ,EAAE,GAAG,SAAS,EAC3B,MAAM,GAAE,YAAiB,GACxB,eAAe,EAAE,CA2BnB"}

package/dist/recipes/index.js

@@ -0,0 +1,41 @@
+import { buildAuthScenarios } from './auth.js';
+import { buildA11yScenarios } from './a11y.js';
+import { buildNavScenarios } from './nav.js';
+import { buildSeedScenarios } from './seed.js';
+export { buildAuthScenarios } from './auth.js';
+export { buildA11yScenarios } from './a11y.js';
+export { buildNavScenarios } from './nav.js';
+export { buildSeedScenarios } from './seed.js';
+/**
+ * Expand a list of RecipeIds into their NeutralScenario arrays, applying
+ * optional per-recipe config. Returns an empty array when ids is empty or
+ * undefined — safe to call unconditionally.
+ */
+export function expandRecipes(ids, config = {}) {
+    if (!ids || ids.length === 0)
+        return [];
+    const scenarios = [];
+    for (const id of ids) {
+        switch (id) {
+            case 'auth':
+                scenarios.push(...buildAuthScenarios(config));
+                break;
+            case 'a11y':
+                scenarios.push(...buildA11yScenarios(config));
+                break;
+            case 'nav':
+                scenarios.push(...buildNavScenarios(config));
+                break;
+            case 'seed':
+                scenarios.push(...buildSeedScenarios(config));
+                break;
+            default: {
+                // TypeScript exhaustiveness: if a new RecipeId is added without a case
+                // this will cause a compile error.
+                const _exhaustive = id;
+                throw new Error(`Unknown recipe id: ${String(_exhaustive)}`);
+            }
+        }
+    }
+    return scenarios;
+}

package/dist/recipes/nav.d.ts

@@ -0,0 +1,34 @@
+/**
+ * nav recipe — navigation, deep-linking, back/forward, 404 handling.
+ *
+ * Lifted from the PROVEN NQ-2 Playwright navigation suite and CaseLoom Cypress
+ * navigation specs. Real selector and navigation patterns, re-derived from
+ * first principles.
+ *
+ * NQ-2 Playwright nav reference patterns:
+ *   - page.goto('/about')
+ *   - expect(page).toHaveURL(/\/about/)
+ *   - await page.goBack()
+ *   - expect(page).toHaveURL('/')
+ *   - page.goto('/nonexistent-route-that-404s')
+ *   - expect(page.locator('[data-testid=not-found]')).toBeVisible()  OR
+ *   - expect(page.getByText('404')).toBeVisible()
+ *
+ * CaseLoom Cypress nav reference patterns:
+ *   - cy.visit('/about')
+ *   - cy.url().should('include', '/about')
+ *   - cy.go('back')
+ *   - cy.url().should('eq', Cypress.config('baseUrl') + '/')
+ */
+import type { NeutralScenario } from '../schemas/gap-analysis.schema.js';
+import type { RecipeConfig } from '../schemas/recipe.schema.js';
+/**
+ * Generate NeutralScenarios for the nav recipe.
+ *
+ * Returns 3 scenarios:
+ *   1. Deep-link routes — direct navigation lands on the correct page
+ *   2. Browser-back — back button returns to the previous route
+ *   3. 404 handling — unknown routes show a user-friendly not-found page
+ */
+export declare function buildNavScenarios(config?: RecipeConfig): NeutralScenario[];
+//# sourceMappingURL=nav.d.ts.map

package/dist/recipes/nav.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nav.d.ts","sourceRoot":"","sources":["../../src/recipes/nav.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACzE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAIhE;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,GAAE,YAAiB,GAAG,eAAe,EAAE,CA2H9E"}

package/dist/recipes/nav.js

@@ -0,0 +1,128 @@
+const DEFAULT_ROUTES = ['/', '/about', '/404'];
+/**
+ * Generate NeutralScenarios for the nav recipe.
+ *
+ * Returns 3 scenarios:
+ *   1. Deep-link routes — direct navigation lands on the correct page
+ *   2. Browser-back — back button returns to the previous route
+ *   3. 404 handling — unknown routes show a user-friendly not-found page
+ */
+export function buildNavScenarios(config = {}) {
+    const routes = config.navRoutes ?? DEFAULT_ROUTES;
+    // Pick up to 3 routes (root + 1 deep + 404 fallback); guard against an empty list.
+    const root = routes[0] ?? '/';
+    const deep = routes[1] ?? '/about';
+    return [
+        {
+            id: 'recipe-nav-deep-link',
+            title: 'Direct navigation to a deep route lands on the correct page',
+            description: 'Visiting a non-root route directly (without clicking through) loads the right content — SPA routing and server-side routing both produce the expected page',
+            targetPath: deep,
+            steps: [
+                {
+                    action: 'navigate',
+                    target: deep,
+                    description: `Navigate directly to ${deep}`,
+                },
+                {
+                    action: 'assert-visible',
+                    target: 'main',
+                    description: 'Main content region is visible — page loaded',
+                },
+                {
+                    action: 'assert-visible',
+                    target: 'h1',
+                    description: 'Page has a heading — correct content loaded, not an error page',
+                },
+            ],
+            tags: ['nav', 'smoke', 'recipe-nav'],
+            recommendations: [
+                {
+                    adapter: 'playwright',
+                    reason: 'Proven NQ-2 nav pattern — page.goto + toHaveURL + heading assertion',
+                    confidence: 'high',
+                },
+                {
+                    adapter: 'cypress-e2e',
+                    reason: 'Proven CaseLoom nav pattern — cy.visit + cy.url().should',
+                    confidence: 'high',
+                },
+            ],
+            sourceGapIds: ['recipe-nav'],
+        },
+        {
+            id: 'recipe-nav-browser-back',
+            title: 'Browser back button returns to the previous route',
+            description: 'After navigating from the root to a deep route, pressing browser-back returns the user to the root — history stack is correctly maintained',
+            targetPath: deep,
+            steps: [
+                {
+                    action: 'navigate',
+                    target: root,
+                    description: `Start at the root (${root})`,
+                },
+                {
+                    action: 'navigate',
+                    target: deep,
+                    description: `Navigate forward to ${deep}`,
+                },
+                {
+                    action: 'assert-visible',
+                    target: 'h1',
+                    description: 'Deep-route page loaded successfully',
+                },
+                {
+                    action: 'wait',
+                    value: '300',
+                    description: 'Let the navigation history settle',
+                },
+            ],
+            tags: ['nav', 'history', 'recipe-nav'],
+            recommendations: [
+                {
+                    adapter: 'playwright',
+                    reason: 'page.goBack() proves history is intact — proven NQ-2 pattern',
+                    confidence: 'medium',
+                },
+                {
+                    adapter: 'cypress-e2e',
+                    reason: 'cy.go("back") — proven CaseLoom history pattern',
+                    confidence: 'medium',
+                },
+            ],
+            sourceGapIds: ['recipe-nav'],
+        },
+        {
+            id: 'recipe-nav-404-handling',
+            title: 'Unknown routes show a user-friendly 404 page',
+            description: 'Navigating to a non-existent route renders a helpful not-found page rather than a blank screen or an unhandled JS error',
+            targetPath: '/this-route-definitely-does-not-exist-qulib-404-probe',
+            steps: [
+                {
+                    action: 'navigate',
+                    target: '/this-route-definitely-does-not-exist-qulib-404-probe',
+                    description: 'Navigate to a route guaranteed to be absent',
+                },
+                {
+                    action: 'assert-visible',
+                    target: 'h1',
+                    description: 'A heading is visible — the app renders a page (not-found or otherwise) rather than a blank error',
+                },
+            ],
+            tags: ['nav', 'error-handling', 'recipe-nav'],
+            recommendations: [
+                {
+                    adapter: 'playwright',
+                    reason: 'page.getByText("404") / not-found selector — proven NQ-2 error-handling pattern',
+                    confidence: 'medium',
+                },
+                {
+                    adapter: 'cypress-e2e',
+                    reason: 'cy.get fallback chain on error/not-found markers',
+                    confidence: 'medium',
+                },
+            ],
+            sourceGapIds: ['recipe-nav'],
+        },
+    ];
+}

package/dist/recipes/seed.d.ts

@@ -0,0 +1,34 @@
+/**
+ * seed recipe — data-seeding and state-reset helpers.
+ *
+ * Lifted from the PROVEN NQ-2 Playwright + CaseLoom Cypress test-data patterns.
+ * Re-derived from first principles — not copy-pasted.
+ *
+ * NQ-2 Playwright seed reference patterns:
+ *   - await request.post('/api/test/reset', { data: {} })
+ *   - expect(response.status()).toBe(200)
+ *   - await request.post('/api/test/seed', { data: { scenario: 'default' } })
+ *
+ * CaseLoom Cypress seed reference patterns:
+ *   - cy.request('POST', '/api/test/reset')
+ *   - cy.request('POST', '/api/test/seed', { scenario: 'default' })
+ *   - cy.request({ method: 'DELETE', url: '/api/test/all' }).its('status').should('be.oneOf', [200, 204])
+ *
+ * The seed recipe is primarily a Playwright/API recipe because Cypress request()
+ * handles it cleanly, but the NeutralScenario shape covers both adapters via
+ * the api-call action.
+ */
+import type { NeutralScenario } from '../schemas/gap-analysis.schema.js';
+import type { RecipeConfig } from '../schemas/recipe.schema.js';
+/**
+ * Generate NeutralScenarios for the seed recipe.
+ *
+ * Returns 2 scenarios:
+ *   1. State reset — POST to the reset endpoint returns 200/204 (clean slate)
+ *   2. Seed + verify — POST seed then verify the seeded UI state is visible
+ *
+ * These are rendered as api-call steps, which both adapters handle (Cypress via
+ * cy.request, Playwright via page.request.post).
+ */
+export declare function buildSeedScenarios(config?: RecipeConfig): NeutralScenario[];
+//# sourceMappingURL=seed.d.ts.map

package/dist/recipes/seed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seed.d.ts","sourceRoot":"","sources":["../../src/recipes/seed.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACzE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAKhE;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,GAAE,YAAiB,GAAG,eAAe,EAAE,CA6E/E"}

package/dist/recipes/seed.js

@@ -0,0 +1,87 @@
+const DEFAULT_SEED_ENDPOINT = '/api/test/seed';
+const DEFAULT_RESET_ENDPOINT = '/api/test/reset';
+/**
+ * Generate NeutralScenarios for the seed recipe.
+ *
+ * Returns 2 scenarios:
+ *   1. State reset — POST to the reset endpoint returns 200/204 (clean slate)
+ *   2. Seed + verify — POST seed then verify the seeded UI state is visible
+ *
+ * These are rendered as api-call steps, which both adapters handle (Cypress via
+ * cy.request, Playwright via page.request.post).
+ */
+export function buildSeedScenarios(config = {}) {
+    const seedEndpoint = config.seedEndpoint ?? DEFAULT_SEED_ENDPOINT;
+    const resetEndpoint = DEFAULT_RESET_ENDPOINT;
+    return [
+        {
+            id: 'recipe-seed-reset',
+            title: 'Test state reset endpoint returns a success status',
+            description: 'POSTing to the reset endpoint clears test data and returns 200 — the test teardown contract is honoured',
+            targetPath: resetEndpoint,
+            steps: [
+                {
+                    action: 'api-call',
+                    target: resetEndpoint,
+                    description: 'POST to the reset endpoint — expect 200/204',
+                },
+            ],
+            tags: ['seed', 'setup', 'recipe-seed'],
+            recommendations: [
+                {
+                    adapter: 'playwright',
+                    reason: 'page.request.post / apiRequest — proven NQ-2 data-setup pattern',
+                    confidence: 'high',
+                },
+                {
+                    adapter: 'cypress-e2e',
+                    reason: 'cy.request("POST", url) — proven CaseLoom seed pattern',
+                    confidence: 'high',
+                },
+                {
+                    adapter: 'api',
+                    reason: 'Direct API seed — no browser required',
+                    confidence: 'high',
+                },
+            ],
+            sourceGapIds: ['recipe-seed'],
+        },
+        {
+            id: 'recipe-seed-and-verify',
+            title: 'Seed endpoint populates data that is visible in the UI',
+            description: 'After seeding the default dataset, the UI reflects the seeded state — the test pipeline can establish known state before running assertions',
+            targetPath: '/',
+            steps: [
+                {
+                    action: 'api-call',
+                    target: seedEndpoint,
+                    description: `POST to seed endpoint (${seedEndpoint}) to populate default test data`,
+                },
+                {
+                    action: 'navigate',
+                    target: '/',
+                    description: 'Navigate to the app root to verify the seeded state is visible',
+                },
+                {
+                    action: 'assert-visible',
+                    target: 'main',
+                    description: 'Application loaded with seeded data',
+                },
+            ],
+            tags: ['seed', 'data-setup', 'recipe-seed'],
+            recommendations: [
+                {
+                    adapter: 'playwright',
+                    reason: 'Proven NQ-2 seed + navigate pattern — set state before assertions',
+                    confidence: 'medium',
+                },
+                {
+                    adapter: 'cypress-e2e',
+                    reason: 'cy.request seed then cy.visit — proven CaseLoom setup pattern',
+                    confidence: 'medium',
+                },
+            ],
+            sourceGapIds: ['recipe-seed'],
+        },
+    ];
+}

package/dist/reporters/heatmap.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Per-page coverage heatmap for Markdown reports.
+ *
+ * buildPageHeatmap() is a pure function — no I/O, no side-effects.
+ * It derives a rows × dimensions matrix from GapAnalysis.gaps and sorts
+ * rows worst-first (most critical coverage problems bubble to the top).
+ *
+ * Dimensions map to the GapSchema.category enum values so the heatmap
+ * always stays in sync with what the scanner can produce.
+ */
+import type { Gap } from '../schemas/gap-analysis.schema.js';
+/** The ordered set of gap categories that appear as heatmap columns. */
+export declare const HEATMAP_DIMENSIONS: readonly ["untested-route", "a11y", "console-error", "broken-link", "coverage", "untested-api-endpoint", "auth-surface"];
+export type HeatmapDimension = (typeof HEATMAP_DIMENSIONS)[number];
+/** Display labels for each dimension column header. */
+export declare const DIMENSION_LABELS: Record<HeatmapDimension, string>;
+/** One cell in the heatmap: the worst severity for that page × dimension. */
+export type HeatmapCell = {
+    /** Worst Gap severity found, or null when no gap exists. */
+    worstSeverity: Gap['severity'] | null;
+    /** Glyph to render in Markdown. */
+    glyph: string;
+    /** Count of gaps contributing to this cell. */
+    count: number;
+};
+/** One row in the heatmap: a page path and its per-dimension cells. */
+export type HeatmapRow = {
+    path: string;
+    /** Map from dimension to cell. Guaranteed to contain every HEATMAP_DIMENSION key. */
+    cells: Record<HeatmapDimension, HeatmapCell>;
+    /** Sum of severity scores across all cells — used for worst-first sort. */
+    worstScore: number;
+};
+/** The full heatmap structure returned by buildPageHeatmap(). */
+export type PageHeatmap = {
+    /** Rows sorted worst-first (highest total severity score first). */
+    rows: HeatmapRow[];
+    /** Ordered dimension labels for use as column headers. */
+    dimensions: typeof HEATMAP_DIMENSIONS;
+    /** Total number of gaps that fed into the heatmap. */
+    totalGaps: number;
+};
+/**
+ * Build a per-page coverage heatmap from a flat list of gaps.
+ *
+ * @param gaps  The gaps array from GapAnalysis.
+ * @returns     A PageHeatmap with rows sorted worst-first.
+ */
+export declare function buildPageHeatmap(gaps: Gap[]): PageHeatmap;
+/**
+ * Render a PageHeatmap as a Markdown section string.
+ * Returns an empty string when there are no rows (nothing scanned).
+ */
+export declare function renderHeatmapSection(heatmap: PageHeatmap): string;
+//# sourceMappingURL=heatmap.d.ts.map

package/dist/reporters/heatmap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heatmap.d.ts","sourceRoot":"","sources":["../../src/reporters/heatmap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,mCAAmC,CAAC;AAM7D,wEAAwE;AACxE,eAAO,MAAM,kBAAkB,0HAQoB,CAAC;AAEpD,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEnE,uDAAuD;AACvD,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,gBAAgB,EAAE,MAAM,CAQ7D,CAAC;AAuBF,6EAA6E;AAC7E,MAAM,MAAM,WAAW,GAAG;IACxB,4DAA4D;IAC5D,aAAa,EAAE,GAAG,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC;IACtC,mCAAmC;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,+CAA+C;IAC/C,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,uEAAuE;AACvE,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,qFAAqF;IACrF,KAAK,EAAE,MAAM,CAAC,gBAAgB,EAAE,WAAW,CAAC,CAAC;IAC7C,2EAA2E;IAC3E,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,iEAAiE;AACjE,MAAM,MAAM,WAAW,GAAG;IACxB,oEAAoE;IACpE,IAAI,EAAE,UAAU,EAAE,CAAC;IACnB,0DAA0D;IAC1D,UAAU,EAAE,OAAO,kBAAkB,CAAC;IACtC,sDAAsD;IACtD,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAMF;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,WAAW,CAuDzD;AAMD;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAmCjE"}