@questpie/admin 2.0.0 → 3.0.0

package/skills/questpie-admin/views/SKILL.md

@@ -0,0 +1,442 @@
+---
+name: questpie-admin/views
+description: QUESTPIE admin views list-view table form-view sections sidebar dashboard widgets filters bulk-actions visibility history versioning sorting search
+type: skill
+---
+
+# QUESTPIE Admin Views
+
+This skill builds on questpie-admin.
+
+Views control how data appears in the QUESTPIE admin panel. They are configured **server-side** on collections and globals, then rendered by the admin client via registries.
+
+```text
+Server Config                     Admin UI
+.list(({ v }) => v.collectionTable({}))   ->  Table with columns, sort, search
+.form(({ v, f }) => v.collectionForm({})) ->  Form with sections, sidebar, tabs
+sidebar({...})                 ->  Navigation sidebar
+dashboard({...})               ->  Dashboard with widgets
+```
+
+## List Views
+
+Configure table views with `.list()` on a collection.
+
+### Basic Table
+
+```ts
+.list(({ v }) => v.collectionTable({}))
+```
+
+Shows all fields as columns with default rendering.
+
+### Custom Columns and Search
+
+```ts
+.list(({ v, f }) =>
+  v.collectionTable({
+    columns: [f.name, f.email, f.isActive, f.createdAt],
+    searchableFields: [f.name, f.email],
+    defaultSort: { field: f.createdAt, direction: "desc" },
+  }),
+)
+```
+
+| Option             | Type                   | Description                    |
+| ------------------ | ---------------------- | ------------------------------ |
+| `columns`          | `Field[]`              | Fields to show as columns      |
+| `searchableFields` | `Field[]`              | Fields included in text search |
+| `defaultSort`      | `{ field, direction }` | Default sort order             |
+
+## Form Views
+
+Configure edit forms with `.form()`.
+
+### Basic Form
+
+```ts
+.form(({ v, f }) => v.collectionForm({}))
+```
+
+Renders all fields in a single column.
+
+### Sections
+
+Group fields into labeled sections with optional grid layout:
+
+```ts
+.form(({ v, f }) =>
+  v.collectionForm({
+    fields: [
+      {
+        type: "section",
+        label: { en: "Contact Information" },
+        layout: "grid",
+        columns: 2,
+        fields: [f.name, f.email, f.phone],
+      },
+      {
+        type: "section",
+        label: { en: "Profile" },
+        fields: [f.bio],
+      },
+    ],
+  }),
+)
+```
+
+| Option        | Type                | Description                          |
+| ------------- | ------------------- | ------------------------------------ |
+| `type`        | `"section"`         | Required                             |
+| `label`       | `string \| i18n`    | Section heading                      |
+| `description` | `string \| i18n`    | Section description                  |
+| `layout`      | `"grid" \| "stack"` | Field layout                         |
+| `columns`     | `number`            | Grid columns (with `layout: "grid"`) |
+| `fields`      | `Field[]`           | Fields in this section               |
+
+### Form Sidebar
+
+Place fields in a right sidebar panel:
+
+```ts
+.form(({ v, f }) =>
+  v.collectionForm({
+    sidebar: {
+      position: "right",
+      fields: [f.isActive, f.avatar, f.status],
+    },
+    fields: [ /* main content sections */ ],
+  }),
+)
+```
+
+### Computed Fields
+
+Auto-compute values from other fields:
+
+```ts
+{
+  field: f.slug,
+  compute: {
+    handler: ({ data }) => {
+      if (data.name && !data.slug?.trim()) {
+        return slugify(data.name);
+      }
+      return undefined;
+    },
+    deps: ({ data }) => [data.name, data.slug],
+    debounce: 300,
+  },
+}
+```
+
+| Option     | Type             | Description              |
+| ---------- | ---------------- | ------------------------ |
+| `handler`  | `(ctx) => value` | Compute function         |
+| `deps`     | `(ctx) => any[]` | Reactive dependencies    |
+| `debounce` | `number`         | Debounce in milliseconds |
+
+### Conditional Visibility
+
+Show or hide fields based on other field values:
+
+```ts
+{
+  field: f.cancellationReason,
+  hidden: ({ data }) => data.status !== "cancelled",
+}
+```
+
+Read-only fields:
+
+```ts
+{
+  field: f.customerName,
+  readOnly: ({ data }) => !!data.customer,
+}
+```
+
+Section-level visibility:
+
+```ts
+{
+  type: "section",
+  label: { en: "SEO" },
+  hidden: ({ data }) => !data.isPublished,
+  fields: [f.metaTitle, f.metaDescription],
+}
+```
+
+## Dashboard
+
+Configure with `dashboard.ts`:
+
+```ts title="dashboard.ts"
+import { dashboard } from "#questpie";
+
+export default dashboard({
+	title: { en: "Dashboard" },
+	description: { en: "Overview of your app" },
+	columns: 4,
+	actions: [
+		{
+			id: "new-post",
+			href: "/admin/collections/posts?create=true",
+			label: { en: "New Post" },
+			icon: { type: "icon", props: { name: "ph:plus" } },
+			variant: "primary",
+		},
+	],
+	sections: [
+		{ id: "today", label: { en: "Today" }, layout: "grid", columns: 4 },
+		{ id: "business", label: { en: "Business" }, layout: "grid", columns: 4 },
+	],
+	items: [
+		/* widget items — see widget types below */
+	],
+});
+```
+
+### Widget Types
+
+**Stats** — count records with optional filter:
+
+```ts
+{
+  sectionId: "today",
+  id: "pending",
+  type: "stats",
+  collection: "appointments",
+  label: { en: "Pending" },
+  filter: { status: "pending" },
+  span: 1,
+}
+```
+
+**Value** — custom-loaded value with trend:
+
+```ts
+{
+  sectionId: "business",
+  id: "revenue",
+  type: "value",
+  span: 2,
+  refreshInterval: 1000 * 60 * 5,
+  loader: async ({ app }) => ({
+    value: 42000,
+    formatted: "42,000 EUR",
+    label: { en: "Monthly Revenue" },
+    trend: { value: "+12%" },
+  }),
+}
+```
+
+**Progress** — progress bar toward a goal:
+
+```ts
+{
+  sectionId: "business",
+  id: "goal",
+  type: "progress",
+  span: 1,
+  showPercentage: true,
+  label: { en: "Monthly Goal" },
+  loader: async ({ app }) => ({ current: 350, target: 500 }),
+}
+```
+
+**Chart** — chart from field values:
+
+```ts
+{
+  sectionId: "business",
+  id: "by-status",
+  type: "chart",
+  collection: "appointments",
+  field: "status",
+  chartType: "pie",
+  label: { en: "By Status" },
+  span: 1,
+}
+```
+
+**Recent Items** — list recent records:
+
+```ts
+{
+  sectionId: "ops",
+  id: "recent",
+  type: "recentItems",
+  collection: "appointments",
+  label: { en: "Recent" },
+  limit: 6,
+  dateField: "scheduledAt",
+  span: 2,
+}
+```
+
+**Timeline** — activity stream:
+
+```ts
+{
+  sectionId: "ops",
+  id: "activity",
+  type: "timeline",
+  label: { en: "Activity" },
+  maxItems: 8,
+  showTimestamps: true,
+  timestampFormat: "relative",
+  loader: async ({ app }) => {
+    const res = await app.collections.appointments.find({
+      limit: 8,
+      orderBy: { updatedAt: "desc" },
+    });
+    return res.docs.map((apt) => ({
+      id: apt.id,
+      title: apt.displayTitle,
+      description: `Status: ${apt.status}`,
+      timestamp: apt.updatedAt,
+      variant: apt.status === "completed" ? "success" : "warning",
+      href: `/admin/collections/appointments/${apt.id}`,
+    }));
+  },
+  span: 2,
+}
+```
+
+## Sidebar
+
+Configure with `sidebar.ts`:
+
+```ts title="sidebar.ts"
+import { sidebar } from "#questpie";
+
+export default sidebar({
+	sections: [
+		{ id: "overview", title: { en: "Overview" } },
+		{ id: "content", title: { en: "Content" } },
+		{ id: "external", title: { en: "External" } },
+	],
+	items: [
+		// Dashboard link
+		{
+			sectionId: "overview",
+			type: "link",
+			label: { en: "Dashboard" },
+			href: "/admin",
+			icon: { type: "icon", props: { name: "ph:house" } },
+		},
+		// Global settings
+		{ sectionId: "overview", type: "global", global: "siteSettings" },
+		// Collection — label and icon from .admin() config
+		{ sectionId: "content", type: "collection", collection: "posts" },
+		// External link
+		{
+			sectionId: "external",
+			type: "link",
+			label: { en: "Open Website" },
+			href: "/",
+			external: true,
+			icon: { type: "icon", props: { name: "ph:arrow-square-out" } },
+		},
+	],
+});
+```
+
+Items appear in definition order within their section.
+
+Modules contribute sidebar items automatically. `adminModule` adds "Administration" with user management. `auditModule` adds an audit log item.
+
+## Filters & Saved Views
+
+Filters are auto-generated from field definitions:
+
+| Field Type          | Filter Operators                         |
+| ------------------- | ---------------------------------------- |
+| `text`              | Contains, equals, starts with, ends with |
+| `number`            | Equals, greater than, less than, between |
+| `boolean`           | Is true, is false                        |
+| `select`            | Is, is not, in                           |
+| `date` / `datetime` | Before, after, between                   |
+| `relation`          | Is (picker)                              |
+
+Users can save filter + sort + column combinations as named views.
+
+## Bulk Actions
+
+List views support multi-select. Check rows, then use the floating toolbar. Built-in: **Delete** (with confirmation). Soft-delete collections soft-delete instead of permanent removal.
+
+## History & Versions
+
+Click the clock icon in the form toolbar. Two tabs:
+
+| Tab          | Shows                                          | Requires                      |
+| ------------ | ---------------------------------------------- | ----------------------------- |
+| **Activity** | Audit log (create, update, delete, transition) | `auditModule`                 |
+| **Versions** | Full document snapshots with restore           | `.versioning()` on collection |
+
+Enable versioning:
+
+```ts
+export const pages = collection("pages")
+  .versioning({ drafts: true, maxVersions: 20 })
+  .fields(({ f }) => ({ ... }));
+```
+
+Disable audit for a specific collection:
+
+```ts
+export const logs = collection("logs")
+  .admin(() => ({ audit: false }))
+  .fields(({ f }) => ({ ... }));
+```
+
+## Common Mistakes
+
+1. **HIGH: Defining columns that don't match field names** — `columns: [f.name]` requires a `name` field in the collection's `.fields()`. Mismatches cause empty columns.
+
+2. **MEDIUM: Not specifying `searchableFields`** — table search bar won't work unless you explicitly list which fields to search.
+
+3. **MEDIUM: Forgetting sidebar section ordering** — items appear in definition order. If you want "Dashboard" at the top, define it first in the `items` array.
+
+4. **MEDIUM: Missing `sectionId` on sidebar items** — every item must reference an existing section ID.
+
+5. **LOW: Not setting `defaultSort`** — records appear in database insertion order which is usually not what users expect.
+
+## Form Views and Live Preview
+
+Form views connect to the Live Preview V2 system when the collection has `.preview()` configured. The form editor becomes the source of `postMessage` patches — every field change emits a patch through the bus, giving the preview iframe instant updates.
+
+### Enabling Preview on a Collection
+
+Add `.preview()` to the collection definition:
+
+```ts
+export const pages = collection("pages")
+	.fields(({ f }) => ({
+		title: f.text({ required: true, localized: true }),
+		slug: f.text({ required: true }),
+		content: f.blocks({ localized: true }),
+	}))
+	.preview({
+		url: ({ record }) => `/${record.slug}?preview=true`,
+		watch: ["title", "slug", "content"],
+		strategy: "hybrid",
+	});
+```
+
+### Preview Strategy Options
+
+| Strategy    | Use case                                                              |
+| ----------- | --------------------------------------------------------------------- |
+| `"instant"` | Simple pages with no derived fields — fastest, pure client patches    |
+| `"server"`  | Complex forms where every change needs server validation/computation  |
+| `"hybrid"`  | Default recommendation — instant local patches + server reconcile for slugs, relations, computed fields |
+
+### How It Works
+
+1. The form view detects `.preview()` config and opens a split-screen layout
+2. Field edits emit patches via `postMessage` to the preview iframe
+3. The preview page receives patches through `useQuestpiePreview` and updates in place
+4. Save/autosave persists to the database but is NOT the live transport
+5. In `"hybrid"` mode, derived data (slugs, expanded relations) reconciles via server round-trip

package/dist/_virtual/rolldown_runtime.mjs

@@ -1,18 +0,0 @@
-//#region rolldown:runtime
-var __defProp = Object.defineProperty;
-var __exportAll = (all, symbols) => {
-	let target = {};
-	for (var name in all) {
-		__defProp(target, name, {
-			get: all[name],
-			enumerable: true
-		});
-	}
-	if (symbols) {
-		__defProp(target, Symbol.toStringTag, { value: "Module" });
-	}
-	return target;
-};
-
-//#endregion
-export { __exportAll };

package/dist/augmentation.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"augmentation.d.mts","names":[],"sources":["../src/augmentation.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;UAoEiB,aAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA8CG;;;;;;;;;;;uBAYE;;;;;;;;;;;uBAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA8BX;;;;;;;;;;;;;;;;;;;;;UA8BM,kBAAA,SAA2B;;;;;;;;;;UAW3B,mBAAA,SAA4B;;;;;;;;UAS5B,iBAAA,SAA0B;;;;;;;;;;UAW1B,sBAAA,SAA+B;;;;;;;;;;UAW/B,oBAAA,SAA6B;;;;;;;;UAS7B,qBAAA,SAA8B;;;;;;UAO9B,kBAAA,SAA2B;;;;;;UAO3B,kBAAA,SAA2B;;;;;;UAO3B,oBAAA,SAA6B;;;;;;;;;UAU7B,sBAAA,SAA+B;;;;;;;;;;;;UAa/B,oBAAA,SAA6B;;;;;;;;UAS7B,mBAAA,SAA4B;;;;;;;;;;;UAY5B,kBAAA,SAA2B;;;;;;;UAQ3B,oBAAA,SAA6B;;;;;;;UAQ7B,sBAAA,SAA+B;;;;;;;;;;;;;;;;;;;UAoB/B,oBAAA,SAA6B;;;;;;;;;;;;;;;;KAqBlC,YAAA,GACT,qBACA,yBACA,sBACA,oBACA,uBACA,wBACA,qBACA,qBACA,uBACA,yBACA,uBACA,sBACA,qBACA,uBACA,yBACA;;;;UASc,mBAAA;;;;;;;;;;;;;;;;;;;UAoBA,kBAAA"}

package/dist/client/blocks/block-registry.d.mts

@@ -1,199 +0,0 @@
-import * as React$1 from "react";
-
-//#region src/client/blocks/block-registry.d.ts
-
-/**
- * Extract blocks from CMS type.
- * Handles the state.blocks structure from QuestpieBuilder.
- */
-type ExtractServerBlocks<TCMS> = TCMS extends {
-  state: {
-    blocks: infer B;
-  };
-} ? B extends Record<string, any> ? B : Record<string, never> : Record<string, never>;
-/**
- * Get block names from CMS type.
- */
-type ServerBlockNames<TCMS> = keyof ExtractServerBlocks<TCMS>;
-/**
- * Extract field values type from a server block definition.
- * Looks at the block's state.fields and extracts value types.
- */
-type ExtractBlockFieldValues<TBlock> = TBlock extends {
-  state: {
-    fields: infer TFields;
-  };
-} ? TFields extends Record<string, {
-  $types: {
-    value: infer V;
-  };
-}> ? { [K in keyof TFields]: TFields[K]["$types"]["value"] } : Record<string, unknown> : Record<string, unknown>;
-/**
- * Extract prefetch data type from a server block definition.
- * Looks at the block's state.prefetch return type.
- */
-type ExtractBlockPrefetchData<TBlock> = TBlock extends {
-  state: {
-    prefetch: (params: any) => Promise<infer R>;
-  };
-} ? R : TBlock extends {
-  state: {
-    prefetch: (params: any) => infer R;
-  };
-} ? R : undefined;
-/**
- * Block values type for a specific block name in a CMS.
- */
-type BlockValues<TCMS, TBlockName extends keyof ExtractServerBlocks<TCMS>> = ExtractBlockFieldValues<ExtractServerBlocks<TCMS>[TBlockName]>;
-/**
- * Block prefetch data type for a specific block name in a CMS.
- */
-type BlockPrefetchData<TCMS, TBlockName extends keyof ExtractServerBlocks<TCMS>> = ExtractBlockPrefetchData<ExtractServerBlocks<TCMS>[TBlockName]>;
-/**
- * Props passed to block renderer components.
- */
-interface BlockRendererProps<TValues = Record<string, unknown>, TData = unknown> {
-  /** Block instance ID */
-  id: string;
-  /** Block field values */
-  values: TValues;
-  /** Data from server-side prefetch (if block has prefetch defined) */
-  data: TData;
-  /** Rendered child blocks (for layout blocks) */
-  children?: React$1.ReactNode;
-  /** Whether this block is currently selected in the editor */
-  isSelected?: boolean;
-  /** Whether rendering in preview mode */
-  isPreview?: boolean;
-}
-/**
- * Block renderer component type.
- */
-type BlockRendererComponent<TValues = Record<string, unknown>, TData = unknown> = React$1.ComponentType<BlockRendererProps<TValues, TData>>;
-/**
- * Block renderer definition.
- */
-interface BlockRendererDefinition<TValues = Record<string, unknown>, TData = unknown> {
-  /** React component for rendering the block */
-  component: BlockRendererComponent<TValues, TData>;
-}
-/**
- * Type-safe block renderer registry.
- * Tracks which blocks have been registered for type checking.
- */
-interface BlockRegistry<TCMS, TRegistered extends Record<string, BlockRendererDefinition<any, any>> = Record<string, never>> {
-  /**
-   * Register a renderer for a block type.
-   *
-   * @param blockName - Name of the block (must match server block definition)
-   * @param definition - Block renderer definition with component
-   * @returns Updated registry with the new block registered
-   *
-   * @example
-   * ```ts
-   * registry.register("hero", {
-   *   component: ({ values, data }) => <HeroSection {...values} data={data} />
-   * })
-   * ```
-   */
-  register<TBlockName extends ServerBlockNames<TCMS> & string>(blockName: TBlockName, definition: BlockRendererDefinition<BlockValues<TCMS, TBlockName>, BlockPrefetchData<TCMS, TBlockName>>): BlockRegistry<TCMS, TRegistered & { [K in TBlockName]: BlockRendererDefinition<BlockValues<TCMS, TBlockName>, BlockPrefetchData<TCMS, TBlockName>> }>;
-  /**
-   * Get the registered renderers.
-   */
-  readonly renderers: TRegistered;
-  /**
-   * Get a renderer by block name (runtime).
-   */
-  getRenderer(blockName: string): BlockRendererDefinition<any, any> | undefined;
-  /**
-   * Check if a block has a registered renderer (runtime).
-   */
-  hasRenderer(blockName: string): boolean;
-  /**
-   * Get all registered block names (runtime).
-   */
-  getBlockNames(): string[];
-  /**
-   * Render a block by name (runtime helper).
-   */
-  renderBlock(blockName: string, props: Omit<BlockRendererProps<any, any>, "children">, children?: React$1.ReactNode): React$1.ReactNode;
-}
-/**
- * Create a new type-safe block renderer registry.
- *
- * The registry infers block value types from the server CMS type,
- * ensuring type safety without duplicating schema definitions.
- *
- * @template TCMS - Server CMS type (e.g., `typeof cms` or `AppCMS`)
- *
- * @example
- * ```ts
- * import { createBlockRegistry } from "@questpie/admin/client";
- * import type { AppCMS } from "@/server/cms";
- *
- * // Create typed registry
- * export const blockRenderers = createBlockRegistry<AppCMS>()
- *   .register("hero", {
- *     // values is typed: { title: string, subtitle?: string, ... }
- *     // data is typed from prefetch return type
- *     component: ({ values, data }) => (
- *       <section>
- *         <h1>{values.title}</h1>
- *         {values.subtitle && <p>{values.subtitle}</p>}
- *       </section>
- *     ),
- *   })
- *   .register("columns", {
- *     component: ({ values, children }) => (
- *       <div className={`grid grid-cols-${values.columnCount}`}>
- *         {children}
- *       </div>
- *     ),
- *   });
- *
- * // Use in BlockRenderer component
- * function BlockRenderer({ block }: { block: BlockNode }) {
- *   return blockRenderers.renderBlock(
- *     block.type,
- *     { id: block.id, values: blockValues[block.id], data: blockData[block.id] },
- *     block.children.map(child => <BlockRenderer key={child.id} block={child} />)
- *   );
- * }
- * ```
- */
-declare function createBlockRegistry<TCMS>(): BlockRegistry<TCMS, Record<string, never>>;
-/**
- * Extract the component props type for a registered block.
- * Useful when you need to type component props externally.
- *
- * @example
- * ```ts
- * type HeroProps = BlockComponentProps<AppCMS, "hero">;
- * // { id: string; values: HeroValues; data: HeroData; children?: ReactNode; ... }
- * ```
- */
-type BlockComponentProps<TCMS, TBlockName extends ServerBlockNames<TCMS>> = BlockRendererProps<BlockValues<TCMS, TBlockName>, BlockPrefetchData<TCMS, TBlockName>>;
-/**
- * Helper type to get all possible block value types from CMS.
- * Useful for union types or discriminated unions.
- *
- * @example
- * ```ts
- * type AnyBlockValues = AllBlockValues<AppCMS>;
- * // { hero: HeroValues; text: TextValues; columns: ColumnsValues; ... }
- * ```
- */
-type AllBlockValues<TCMS> = { [K in ServerBlockNames<TCMS> & string]: BlockValues<TCMS, K> };
-/**
- * Helper type to get all possible block data types from CMS.
- *
- * @example
- * ```ts
- * type AnyBlockData = AllBlockData<AppCMS>;
- * // { hero: HeroData; featuredPosts: { posts: Post[] }; ... }
- * ```
- */
-type AllBlockData<TCMS> = { [K in ServerBlockNames<TCMS> & string]: BlockPrefetchData<TCMS, K> };
-//#endregion
-export { AllBlockData, AllBlockValues, BlockComponentProps, BlockPrefetchData, BlockRegistry, BlockRendererComponent, BlockRendererDefinition, BlockRendererProps, BlockValues, ExtractBlockFieldValues, ExtractBlockPrefetchData, ExtractServerBlocks, ServerBlockNames, createBlockRegistry };
-//# sourceMappingURL=block-registry.d.mts.map

package/dist/client/blocks/block-registry.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"block-registry.d.mts","names":[],"sources":["../../../src/client/blocks/block-registry.tsx"],"sourcesContent":[],"mappings":";;;;;;;AA2GA;AACY,KA7DA,mBA6DA,CAAA,IAAA,CAAA,GA7D4B,IA6D5B,SAAA;EAMF,KAAA,EAAA;IAEF,MAAA,EAAA,KAAA,EAAA;EAEK,CAAA;CAAe,GAAA,CAAA,SApEd,MAoEc,CAAA,MAAA,EAAA,GAAA,CAAA,GAAA,CAAA,GAlEtB,MAkEsB,CAAA,MAAA,EAAA,KAAA,CAAA,GAjExB,MAiEwB,CAAA,MAAA,EAAA,KAAA,CAAA;AAU5B;;;AAGoD,KAzExC,gBAyEwC,CAAA,IAAA,CAAA,GAAA,MAzET,mBAyES,CAzEW,IAyEX,CAAA;;;;AAKpD;AACY,KAzEA,uBAyEA,CAAA,MAAA,CAAA,GAzEkC,MAyElC,SAAA;EAIwB,KAAA,EAAA;IAAS,MAAA,EAAA,KAAA,QAAA;EAAhC,CAAA;CAAsB,GAAA,OAAA,SA1Ef,MA0Ee,CAAA,MAAA,EAAA;EAWlB,MAAA,EAAA;IAEoB,KAAA,EAAA,KAAA,EAAA;EAAf,CAAA;CAClB,CAAA,GAAA,QAgB2C,MAvG3B,OAuG2B,GAvGjB,OAuGiB,CAvGT,CAuGS,CAAA,CAAA,QAAA,CAAA,CAAA,OAAA,CAAA,EAAjB,GAtGxB,MAsGwB,CAAA,MAAA,EAAA,OAAA,CAAA,GArG1B,MAqG0B,CAAA,MAAA,EAAA,OAAA,CAAA;;;;;AAIN,KAnGZ,wBAmGY,CAAA,MAAA,CAAA,GAnGuB,MAmGvB,SAAA;EAAM,KAAA,EAAA;IAAxB,QAAA,EAAA,CAAA,MAAA,EAAA,GAAA,EAAA,GAlGgC,OAkGhC,CAAA,KAAA,EAAA,CAAA;EAFU,CAAA;CAKZ,GAAA,CAAA,GAlGA,MAkGA,SAAA;EACA,KAAA,EAAA;IACQ,QAAA,EAAA,CAAA,MAAA,EAAA,GAAA,EAAA,GAAA,KAAA,EAAA;EACQ,CAAA;CAAM,GAAA,CAAA,GAAA,SAAA;;;;AAClB,KA/FI,WA+FJ,CAAA,IAAA,EAAA,mBAAA,MA7FmB,mBA6FnB,CA7FuC,IA6FvC,CAAA,CAAA,GA5FJ,uBA4FI,CA5FoB,mBA4FpB,CA5FwC,IA4FxC,CAAA,CA5F8C,UA4F9C,CAAA,CAAA;;;;AAa0B,KApGtB,iBAoGsB,CAAA,IAAA,EAAA,mBAAA,MAlGP,mBAkGO,CAlGa,IAkGb,CAAA,CAAA,GAjG9B,wBAiG8B,CAjGL,mBAiGK,CAjGe,IAiGf,CAAA,CAjGqB,UAiGrB,CAAA,CAAA;;;;AAmB7B,UA3GY,kBA2GN,CAAA,UA1GC,MA0GD,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,QAAA,OAAA,CAAA,CAAA;EAAS;EAmHJ,EAAA,EAAA,MAAA;EACd;EACA,MAAA,EAzNQ,OAyNR;EAF2C;EAAa,IAAA,EArNlD,KAqNkD;EAqB9C;EAE0B,QAAA,CAAA,EA1OzB,OAAA,CAAM,SA0OmB;EAAjB;EAEP,UAAA,CAAA,EAAA,OAAA;EAAM;EAAlB,SAAA,CAAA,EAAA,OAAA;;;;;AADoB,KAjOV,sBAiOU,CAAA,UAhOV,MAgOU,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,QAAA,OAAA,CAAA,GA9NlB,OAAA,CAAM,aA8NY,CA9NE,kBA8NF,CA9NqB,OA8NrB,EA9N8B,KA8N9B,CAAA,CAAA;AAetB;;;AACsD,UAzOrC,uBAyOqC,CAAA,UAxO1C,MAwO0C,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,QAAA,OAAA,CAAA,CAAA;EAAM;EAAlB,SAAA,EApO7B,sBAoO6B,CApON,OAoOM,EApOG,KAoOH,CAAA;;AAY1C;;;;AACkE,UAtOjD,aAsOiD,CAAA,IAAA,EAAA,oBApO5C,MAoO4C,CAAA,MAAA,EApO7B,uBAoO6B,CAAA,GAAA,EAAA,GAAA,CAAA,CAAA,GAnO9D,MAmO8D,CAAA,MAAA,EAAA,KAAA,CAAA,CAAA,CAAA;EAAxB;;;;;;;;;;;;;;8BAnNZ,iBAAiB,2BAChC,wBACC,wBACV,YAAY,MAAM,aAClB,kBAAkB,MAAM,eAEzB,cACD,MACA,sBACQ,aAAa,wBACjB,YAAY,MAAM,aAClB,kBAAkB,MAAM;;;;sBAQV;;;;kCAKY;;;;;;;;;;;;wCAiBvB,KAAK,sDACD,OAAA,CAAM,YAChB,OAAA,CAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmHK,6BAA6B,cAC3C,MACA;;;;;;;;;;;KAmBU,6CAES,iBAAiB,SAClC,mBACF,YAAY,MAAM,aAClB,kBAAkB,MAAM;;;;;;;;;;;KAad,+BACJ,iBAAiB,iBAAiB,YAAY,MAAM;;;;;;;;;;KAYhD,6BACJ,iBAAiB,iBAAiB,kBAAkB,MAAM"}