@objectstack/spec 0.1.1 → 0.2.0

package/dist/data/filter.zod.js

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALL_OPERATORS = exports.LOGICAL_OPERATORS = exports.FILTER_OPERATORS = exports.NormalizedFilterSchema = exports.QueryFilterSchema = exports.FilterConditionSchema = exports.FieldOperatorsSchema = exports.SpecialOperatorSchema = exports.StringOperatorSchema = exports.RangeOperatorSchema = exports.SetOperatorSchema = exports.ComparisonOperatorSchema = exports.EqualityOperatorSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Unified Query DSL Specification
+ *
+ * Based on industry best practices from:
+ * - Prisma ORM
+ * - Strapi CMS
+ * - TypeORM
+ * - LoopBack Framework
+ *
+ * Version: 1.0.0
+ * Status: Draft
+ *
+ * Objective: Define a JSON-based, database-agnostic query syntax standard
+ * for data filtering interactions between frontend and backend APIs.
+ *
+ * Design Principles:
+ * 1. Declarative: Frontend describes "what data to get", not "how to query"
+ * 2. Database Agnostic: Syntax contains no database-specific directives
+ * 3. Type Safe: Structure can be statically inferred by TypeScript
+ * 4. Convention over Configuration: Implicit syntax for common queries
+ */
+// ============================================================================
+// 3.1 Comparison Operators
+// ============================================================================
+/**
+ * Comparison operators for equality and inequality checks.
+ * Supported data types: Any
+ */
+exports.EqualityOperatorSchema = zod_1.z.object({
+    /** Equal to (default) - SQL: = | MongoDB: $eq */
+    $eq: zod_1.z.any().optional(),
+    /** Not equal to - SQL: <> or != | MongoDB: $ne */
+    $ne: zod_1.z.any().optional(),
+});
+/**
+ * Comparison operators for numeric and date comparisons.
+ * Supported data types: Number, Date
+ */
+exports.ComparisonOperatorSchema = zod_1.z.object({
+    /** Greater than - SQL: > | MongoDB: $gt */
+    $gt: zod_1.z.union([zod_1.z.number(), zod_1.z.date()]).optional(),
+    /** Greater than or equal to - SQL: >= | MongoDB: $gte */
+    $gte: zod_1.z.union([zod_1.z.number(), zod_1.z.date()]).optional(),
+    /** Less than - SQL: < | MongoDB: $lt */
+    $lt: zod_1.z.union([zod_1.z.number(), zod_1.z.date()]).optional(),
+    /** Less than or equal to - SQL: <= | MongoDB: $lte */
+    $lte: zod_1.z.union([zod_1.z.number(), zod_1.z.date()]).optional(),
+});
+// ============================================================================
+// 3.2 Set & Range Operators
+// ============================================================================
+/**
+ * Set operators for membership checks.
+ */
+exports.SetOperatorSchema = zod_1.z.object({
+    /** In list - SQL: IN (?, ?, ?) | MongoDB: $in */
+    $in: zod_1.z.array(zod_1.z.any()).optional(),
+    /** Not in list - SQL: NOT IN (...) | MongoDB: $nin */
+    $nin: zod_1.z.array(zod_1.z.any()).optional(),
+});
+/**
+ * Range operator for interval checks (closed interval).
+ * SQL: BETWEEN ? AND ? | MongoDB: $gte AND $lte
+ */
+exports.RangeOperatorSchema = zod_1.z.object({
+    /** Between (inclusive) - takes [min, max] array */
+    $between: zod_1.z.tuple([
+        zod_1.z.union([zod_1.z.number(), zod_1.z.date()]),
+        zod_1.z.union([zod_1.z.number(), zod_1.z.date()])
+    ]).optional(),
+});
+// ============================================================================
+// 3.3 String-Specific Operators
+// ============================================================================
+/**
+ * String pattern matching operators.
+ * Note: Case sensitivity should be handled at backend level.
+ */
+exports.StringOperatorSchema = zod_1.z.object({
+    /** Contains substring - SQL: LIKE %?% | MongoDB: $regex */
+    $contains: zod_1.z.string().optional(),
+    /** Starts with prefix - SQL: LIKE ?% | MongoDB: $regex */
+    $startsWith: zod_1.z.string().optional(),
+    /** Ends with suffix - SQL: LIKE %? | MongoDB: $regex */
+    $endsWith: zod_1.z.string().optional(),
+});
+// ============================================================================
+// 3.5 Special Operators
+// ============================================================================
+/**
+ * Special check operators for null and existence.
+ */
+exports.SpecialOperatorSchema = zod_1.z.object({
+    /** Is null check - SQL: IS NULL (true) / IS NOT NULL (false) | MongoDB: field: null */
+    $null: zod_1.z.boolean().optional(),
+    /** Field exists check (primarily for NoSQL) - MongoDB: $exists */
+    $exist: zod_1.z.boolean().optional(),
+});
+// ============================================================================
+// Combined Field Operators
+// ============================================================================
+/**
+ * All field-level operators combined.
+ * These can be applied to individual fields in a filter.
+ */
+exports.FieldOperatorsSchema = zod_1.z.object({
+    // Equality
+    $eq: zod_1.z.any().optional(),
+    $ne: zod_1.z.any().optional(),
+    // Comparison (numeric/date)
+    $gt: zod_1.z.union([zod_1.z.number(), zod_1.z.date()]).optional(),
+    $gte: zod_1.z.union([zod_1.z.number(), zod_1.z.date()]).optional(),
+    $lt: zod_1.z.union([zod_1.z.number(), zod_1.z.date()]).optional(),
+    $lte: zod_1.z.union([zod_1.z.number(), zod_1.z.date()]).optional(),
+    // Set & Range
+    $in: zod_1.z.array(zod_1.z.any()).optional(),
+    $nin: zod_1.z.array(zod_1.z.any()).optional(),
+    $between: zod_1.z.tuple([
+        zod_1.z.union([zod_1.z.number(), zod_1.z.date()]),
+        zod_1.z.union([zod_1.z.number(), zod_1.z.date()])
+    ]).optional(),
+    // String-specific
+    $contains: zod_1.z.string().optional(),
+    $startsWith: zod_1.z.string().optional(),
+    $endsWith: zod_1.z.string().optional(),
+    // Special
+    $null: zod_1.z.boolean().optional(),
+    $exist: zod_1.z.boolean().optional(),
+});
+/**
+ * Zod schema for recursive filter validation.
+ * Uses z.lazy() to handle recursive structure.
+ */
+exports.FilterConditionSchema = zod_1.z.lazy(() => zod_1.z.record(zod_1.z.string(), zod_1.z.any()).and(zod_1.z.object({
+    $and: zod_1.z.array(exports.FilterConditionSchema).optional(),
+    $or: zod_1.z.array(exports.FilterConditionSchema).optional(),
+    $not: exports.FilterConditionSchema.optional(),
+})));
+// ============================================================================
+// Query Filter Wrapper
+// ============================================================================
+/**
+ * Top-level query filter wrapper.
+ * This is typically used as the "where" clause in a query.
+ *
+ * @example
+ * ```typescript
+ * const filter: QueryFilter = {
+ *   where: {
+ *     status: "active",                    // Implicit equality
+ *     age: { $gte: 18 },                   // Explicit operator
+ *     $or: [                               // Logical combination
+ *       { role: "admin" },
+ *       { email: { $contains: "@company.com" } }
+ *     ],
+ *     profile: {                           // Nested relation
+ *       verified: true
+ *     }
+ *   }
+ * }
+ * ```
+ */
+exports.QueryFilterSchema = zod_1.z.object({
+    where: exports.FilterConditionSchema.optional(),
+});
+// ============================================================================
+// Normalization Utilities (Internal Representation)
+// ============================================================================
+/**
+ * Normalized filter AST structure.
+ * This is the internal representation after converting all syntactic sugar
+ * to explicit operators.
+ *
+ * Stage 1: Normalization Pass
+ * Input:  { age: 18, role: "admin" }
+ * Output: { $and: [{ age: { $eq: 18 } }, { role: { $eq: "admin" } }] }
+ *
+ * This simplifies adapter implementation by providing a consistent structure.
+ */
+exports.NormalizedFilterSchema = zod_1.z.lazy(() => zod_1.z.object({
+    $and: zod_1.z.array(zod_1.z.union([
+        // Field condition: { field: { $op: value } }
+        zod_1.z.record(zod_1.z.string(), exports.FieldOperatorsSchema),
+        // Nested logical group
+        exports.NormalizedFilterSchema,
+    ])).optional(),
+    $or: zod_1.z.array(zod_1.z.union([
+        zod_1.z.record(zod_1.z.string(), exports.FieldOperatorsSchema),
+        exports.NormalizedFilterSchema,
+    ])).optional(),
+    $not: zod_1.z.union([
+        zod_1.z.record(zod_1.z.string(), exports.FieldOperatorsSchema),
+        exports.NormalizedFilterSchema,
+    ]).optional(),
+}));
+// ============================================================================
+// Constants & Metadata
+// ============================================================================
+/**
+ * All supported operator keys.
+ * Useful for validation and parsing.
+ */
+exports.FILTER_OPERATORS = [
+    // Equality
+    '$eq', '$ne',
+    // Comparison
+    '$gt', '$gte', '$lt', '$lte',
+    // Set & Range
+    '$in', '$nin', '$between',
+    // String
+    '$contains', '$startsWith', '$endsWith',
+    // Special
+    '$null', '$exist',
+];
+/**
+ * Logical operator keys.
+ */
+exports.LOGICAL_OPERATORS = ['$and', '$or', '$not'];
+/**
+ * All operator keys (field + logical).
+ */
+exports.ALL_OPERATORS = [...exports.FILTER_OPERATORS, ...exports.LOGICAL_OPERATORS];

package/dist/data/mapping.zod.d.ts

@@ -146,7 +146,111 @@ export declare const MappingSchema: z.ZodObject<{
     extractQuery: z.ZodOptional<z.ZodObject<{
         object: z.ZodString;
         fields: z.ZodOptional<z.ZodArray<z.ZodType<any, z.ZodTypeDef, any>, "many">>;
+        aggregations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            function: z.ZodEnum<["count", "sum", "avg", "min", "max", "count_distinct", "array_agg", "string_agg"]>;
+            field: z.ZodOptional<z.ZodString>;
+            alias: z.ZodString;
+            distinct: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }, {
+            function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }>, "many">>;
+        windowFunctions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            function: z.ZodEnum<["row_number", "rank", "dense_rank", "percent_rank", "lag", "lead", "first_value", "last_value", "sum", "avg", "count", "min", "max"]>;
+            field: z.ZodOptional<z.ZodString>;
+            alias: z.ZodString;
+            over: z.ZodObject<{
+                partitionBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                orderBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    field: z.ZodString;
+                    order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
+                }, "strip", z.ZodTypeAny, {
+                    field: string;
+                    order: "asc" | "desc";
+                }, {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }>, "many">>;
+                frame: z.ZodOptional<z.ZodObject<{
+                    type: z.ZodOptional<z.ZodEnum<["rows", "range"]>>;
+                    start: z.ZodOptional<z.ZodString>;
+                    end: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                }, {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                partitionBy?: string[] | undefined;
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            }, {
+                partitionBy?: string[] | undefined;
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            function: "min" | "max" | "count" | "sum" | "avg" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                partitionBy?: string[] | undefined;
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }, {
+            function: "min" | "max" | "count" | "sum" | "avg" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                partitionBy?: string[] | undefined;
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }>, "many">>;
         filters: z.ZodOptional<z.ZodType<any, z.ZodTypeDef, any>>;
+        joins: z.ZodOptional<z.ZodArray<z.ZodType<any, z.ZodTypeDef, any>, "many">>;
+        groupBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        having: z.ZodOptional<z.ZodType<any, z.ZodTypeDef, any>>;
         sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
             field: z.ZodString;
             order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
@@ -159,6 +263,7 @@ export declare const MappingSchema: z.ZodObject<{
         }>, "many">>;
         top: z.ZodOptional<z.ZodNumber>;
         skip: z.ZodOptional<z.ZodNumber>;
+        distinct: z.ZodOptional<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         object: string;
         sort?: {
@@ -166,7 +271,34 @@ export declare const MappingSchema: z.ZodObject<{
             order: "asc" | "desc";
         }[] | undefined;
         fields?: any[] | undefined;
+        distinct?: boolean | undefined;
+        aggregations?: {
+            function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        windowFunctions?: {
+            function: "min" | "max" | "count" | "sum" | "avg" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                partitionBy?: string[] | undefined;
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
         filters?: any;
+        joins?: any[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: any;
         top?: number | undefined;
         skip?: number | undefined;
     }, {
@@ -176,7 +308,34 @@ export declare const MappingSchema: z.ZodObject<{
             order?: "asc" | "desc" | undefined;
         }[] | undefined;
         fields?: any[] | undefined;
+        distinct?: boolean | undefined;
+        aggregations?: {
+            function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        windowFunctions?: {
+            function: "min" | "max" | "count" | "sum" | "avg" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                partitionBy?: string[] | undefined;
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
         filters?: any;
+        joins?: any[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: any;
         top?: number | undefined;
         skip?: number | undefined;
     }>>;
@@ -185,7 +344,7 @@ export declare const MappingSchema: z.ZodObject<{
     batchSize: z.ZodDefault<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     name: string;
-    mode: "insert" | "update" | "upsert";
+    mode: "update" | "upsert" | "insert";
     sourceFormat: "json" | "csv" | "xml" | "sql";
     targetObject: string;
     fieldMapping: {
@@ -213,7 +372,34 @@ export declare const MappingSchema: z.ZodObject<{
             order: "asc" | "desc";
         }[] | undefined;
         fields?: any[] | undefined;
+        distinct?: boolean | undefined;
+        aggregations?: {
+            function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        windowFunctions?: {
+            function: "min" | "max" | "count" | "sum" | "avg" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                partitionBy?: string[] | undefined;
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
         filters?: any;
+        joins?: any[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: any;
         top?: number | undefined;
         skip?: number | undefined;
     } | undefined;
@@ -235,7 +421,7 @@ export declare const MappingSchema: z.ZodObject<{
         transform?: "lookup" | "join" | "map" | "none" | "constant" | "split" | "javascript" | undefined;
     }[];
     label?: string | undefined;
-    mode?: "insert" | "update" | "upsert" | undefined;
+    mode?: "update" | "upsert" | "insert" | undefined;
     sourceFormat?: "json" | "csv" | "xml" | "sql" | undefined;
     upsertKey?: string[] | undefined;
     extractQuery?: {
@@ -245,7 +431,34 @@ export declare const MappingSchema: z.ZodObject<{
             order?: "asc" | "desc" | undefined;
         }[] | undefined;
         fields?: any[] | undefined;
+        distinct?: boolean | undefined;
+        aggregations?: {
+            function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        windowFunctions?: {
+            function: "min" | "max" | "count" | "sum" | "avg" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                partitionBy?: string[] | undefined;
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
         filters?: any;
+        joins?: any[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: any;
         top?: number | undefined;
         skip?: number | undefined;
     } | undefined;

package/dist/data/mapping.zod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mapping.zod.d.ts","sourceRoot":"","sources":["../../src/data/mapping.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;GAGG;AACH,eAAO,MAAM,aAAa,iFAQxB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,kBAAkB;IAC7B,oBAAoB;;IAGpB,mBAAmB;;IAGnB,qBAAqB;;IAGrB,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBlC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,aAAa;IACxB,eAAe;;;IAIf,YAAY;;;IAIZ,sBAAsB;;QAzCtB,oBAAoB;;QAGpB,mBAAmB;;QAGnB,qBAAqB;;QAGrB,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAmClC,mBAAmB;;;IAInB,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGjC,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGrB,CAAC;AAEH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AACpD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}
+{"version":3,"file":"mapping.zod.d.ts","sourceRoot":"","sources":["../../src/data/mapping.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;GAGG;AACH,eAAO,MAAM,aAAa,iFAQxB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,kBAAkB;IAC7B,oBAAoB;;IAGpB,mBAAmB;;IAGnB,qBAAqB;;IAGrB,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBlC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,aAAa;IACxB,eAAe;;;IAIf,YAAY;;;IAIZ,sBAAsB;;QAzCtB,oBAAoB;;QAGpB,mBAAmB;;QAGnB,qBAAqB;;QAGrB,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAmClC,mBAAmB;;;IAInB,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGjC,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGrB,CAAC;AAEH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AACpD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}