leangraph 1.0.0

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,YAAY,EACV,KAAK,EACL,MAAM,EACN,YAAY,EACZ,WAAW,EACX,WAAW,EACX,SAAS,EACT,YAAY,EACZ,YAAY,EACZ,WAAW,EACX,mBAAmB,EACnB,WAAW,EACX,cAAc,EACd,UAAU,EACV,aAAa,EACb,YAAY,EACZ,WAAW,EACX,UAAU,GACX,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AACxD,YAAY,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEvE,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AACzD,YAAY,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAEzE,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AACvD,YAAY,EAAE,eAAe,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEpF,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACtD,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE/D,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEhF,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AACxE,YAAY,EAAE,YAAY,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzE,eAAO,MAAM,OAAO,UAAU,CAAC"}

package/dist/server.js

@@ -0,0 +1,25 @@
+// LeanGraph Server - Entry Point
+export { parse } from "./parser.js";
+export { translate, Translator } from "./translator.js";
+export { GraphDatabase, DatabaseManager } from "./db.js";
+export { Executor, executeQuery } from "./executor.js";
+export { createApp, createServer } from "./routes.js";
+export { BackupManager } from "./backup.js";
+export { ApiKeyStore, authMiddleware, generateApiKey } from "./auth.js";
+export const VERSION = "0.1.0";
+// If this file is run directly, start the server
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const { serve } = await import("@hono/node-server");
+    const { createServer } = await import("./routes");
+    const port = parseInt(process.env.PORT || "3000", 10);
+    const dataPath = process.env.DATA_PATH || "./data";
+    const { app, dbManager } = createServer({ port, dataPath });
+    console.log(`LeanGraph Server v${VERSION}`);
+    console.log(`Starting on http://localhost:${port}`);
+    console.log(`Data path: ${dataPath}`);
+    serve({
+        fetch: app.fetch,
+        port,
+    });
+}
+//# sourceMappingURL=server.js.map

package/dist/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA,iCAAiC;AAEjC,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAqBpC,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAGxD,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAGzD,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAGvD,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAGtD,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAG5C,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAGxE,MAAM,CAAC,MAAM,OAAO,GAAG,OAAO,CAAC;AAE/B,iDAAiD;AACjD,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,KAAK,UAAU,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;IACpD,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,MAAM,CAAC,mBAAmB,CAAC,CAAC;IACpD,MAAM,EAAE,YAAY,EAAE,GAAG,MAAM,MAAM,CAAC,UAAU,CAAC,CAAC;IAElD,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,IAAI,MAAM,EAAE,EAAE,CAAC,CAAC;IACtD,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,SAAS,IAAI,QAAQ,CAAC;IAEnD,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,YAAY,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;IAE5D,OAAO,CAAC,GAAG,CAAC,qBAAqB,OAAO,EAAE,CAAC,CAAC;IAC5C,OAAO,CAAC,GAAG,CAAC,gCAAgC,IAAI,EAAE,CAAC,CAAC;IACpD,OAAO,CAAC,GAAG,CAAC,cAAc,QAAQ,EAAE,CAAC,CAAC;IAEtC,KAAK,CAAC;QACJ,KAAK,EAAE,GAAG,CAAC,KAAK;QAChB,IAAI;KACL,CAAC,CAAC;AACL,CAAC"}

package/dist/translator.d.ts

@@ -0,0 +1,330 @@
+import { Query, WithClause } from "./parser.js";
+export interface SqlStatement {
+    sql: string;
+    params: unknown[];
+}
+export interface TranslationResult {
+    statements: SqlStatement[];
+    returnColumns?: string[];
+}
+export interface TranslationContext {
+    variables: Map<string, {
+        type: "node" | "edge" | "path" | "varLengthEdge";
+        alias: string;
+        pathCteName?: string;
+        id?: string;
+    }>;
+    paramValues: Record<string, unknown>;
+    aliasCounter: number;
+    withClauses?: WithClause[];
+}
+export declare class Translator {
+    private ctx;
+    constructor(paramValues?: Record<string, unknown>);
+    translate(query: Query): TranslationResult;
+    /**
+     * Validate and translate a SKIP or LIMIT expression
+     * Throws an error if the value is negative
+     */
+    private translateSkipLimitExpression;
+    private translateClause;
+    private translateCreate;
+    private translateCreateNode;
+    private translateCreateRelationship;
+    private translateMatch;
+    private registerPathExpression;
+    private registerNodePattern;
+    private registerRelationshipPattern;
+    private translateMerge;
+    private translateSet;
+    private assertValidPropertyValueExpression;
+    /**
+     * Evaluate an object expression to get its key-value pairs.
+     */
+    private evaluateObjectExpression;
+    private translateRemove;
+    private translateDelete;
+    private translateReturn;
+    private translateWith;
+    private translateReturnFromCall;
+    private translateVariableLengthPath;
+    private translateUnion;
+    private translateUnwind;
+    private translateCall;
+    private translateCallWhere;
+    private translateExpressionForCall;
+    private lookupWithAliasExpression;
+    private translateExpression;
+    private translateCaseExpression;
+    /**
+     * Get the Cypher type string for an expression (for type-aware comparison in CASE)
+     */
+    private getCypherTypeForExpression;
+    private translateBinaryExpression;
+    private tryTranslateTemporalDurationArithmetic;
+    private isListExpression;
+    private isObjectExpression;
+    private isStringConcatenation;
+    /**
+     * Check if an expression could produce NaN (IEEE 754 Not a Number).
+     * In SQLite, division by zero returns NULL, but Cypher semantics require NaN.
+     * NaN has special comparison semantics: NaN = x is always false, NaN <> x is always true.
+     */
+    private couldProduceNaN;
+    private wrapForArray;
+    private wrapForArithmetic;
+    /**
+     * Translate an expression for a SET on a just-created node.
+     * Property references need to use subqueries since the node ID isn't a table alias.
+     */
+    private translateExpressionForCreatedNode;
+    private isBooleanProducingExpression;
+    private normalizeForBooleanComparison;
+    private translateComparisonExpression;
+    private wrapForComparison;
+    private translateObjectLiteral;
+    private translateArrayLiteral;
+    /**
+     * Translate a list comprehension expression.
+     * Syntax: [variable IN listExpr WHERE filterCondition | mapExpr]
+     *
+     * Translates to SQLite using json_each and json_group_array:
+     * (SELECT json_group_array(value_or_mapped) FROM json_each(listExpr) WHERE filter)
+     */
+    private translateListComprehension;
+    /**
+     * Translate a pattern comprehension expression.
+     * Syntax: [(pattern) WHERE filterCondition | mapExpr]
+     *
+     * Pattern comprehensions match a pattern starting from bound variables and
+     * return a list of results from the mapExpr (or pattern elements if no mapExpr).
+     *
+     * Example: [(a)-[:T|OTHER]->() | 1] returns a list of 1s for each matching edge
+     */
+    private translatePatternComprehension;
+    /**
+     * Translate an expression within a pattern comprehension.
+     */
+    private translatePatternComprehensionExpr;
+    /**
+     * Translate a condition within a pattern comprehension.
+     */
+    private translatePatternComprehensionCondition;
+    /**
+     * Translate an expression within a list comprehension, replacing
+     * references to the comprehension variable with the json_each value column.
+     * Supports scope chains for nested quantifiers.
+     */
+    private translateListComprehensionExpr;
+    /**
+     * Translate a WHERE condition within a list comprehension.
+     * Supports scope chains for nested quantifiers.
+     */
+    private translateListComprehensionCondition;
+    /**
+     * Translate a list predicate expression: ALL/ANY/NONE/SINGLE(var IN list WHERE cond)
+     *
+     * Three-valued logic for handling nulls:
+     * - If predicate evaluation produces NULL (unknown) for any element and no definitive answer, return NULL
+     * - ALL: false if any element fails; null if unknowns present and all definites pass; true otherwise
+     * - ANY: true if any element passes; null if unknowns present and no pass; false otherwise
+     * - NONE: false if any element passes; null if unknowns present and no pass; true otherwise
+     * - SINGLE: false if >1 element passes; null if unknowns present; true if exactly 1 passes; false otherwise
+     *
+     * Unknowns are detected by: (total count) - (matches) - (non-matches) > 0
+     * This correctly handles cases like `WHERE false` where the predicate is static.
+     *
+     * Note: Since the CASE expression uses the list/cond multiple times, we must duplicate
+     * the params for each occurrence.
+     */
+    private translateListPredicate;
+    /**
+     * Translate a nested list predicate within a list comprehension context.
+     * This handles cases like: none(x IN list WHERE none(y IN x WHERE y = 'abc'))
+     * Also handles deeply nested cases: none(x IN list WHERE none(y IN list WHERE x <= y))
+     *
+     * @param expr The nested list predicate expression
+     * @param scopes The scope chain from outer contexts (variable to alias mappings)
+     */
+    private translateNestedListPredicate;
+    /**
+     * Wrap an expression for use with json_each in list predicates
+     */
+    private wrapForListPredicate;
+    /**
+     * Get the static type of an expression when it can be determined at compile time.
+     * Returns the type name for literals and expressions with known types, or null for dynamic types.
+     */
+    private getStaticExpressionType;
+    /**
+     * Check if expression type is valid for boolean operators (AND, OR, NOT).
+     * Throws SyntaxError if the type is definitely invalid.
+     */
+    private validateBooleanOperand;
+    /**
+     * Get the static element type of a list expression (if determinable).
+     * Returns the common element type for literal arrays, or null if mixed or unknown.
+     */
+    private getListElementType;
+    /**
+     * Check if a filter condition uses arithmetic operators on a specific variable.
+     * Returns true if the variable is used with %, /, *, -, or ^ operators.
+     */
+    private conditionUsesArithmeticOnVariable;
+    /**
+     * Check if an expression uses arithmetic operators on a specific variable.
+     * Returns true if the variable is an operand of %, /, *, -, or ^ operators.
+     */
+    private expressionUsesArithmeticOnVariable;
+    /**
+     * Check if an expression directly references a variable.
+     */
+    private expressionReferencesVariable;
+    /**
+     * Validate type compatibility in list predicates (ALL, ANY, NONE, SINGLE).
+     * Throws SyntaxError if using arithmetic on non-numeric list elements.
+     */
+    private validateListPredicateTypes;
+    /**
+     * Translate a unary expression: NOT expr
+     */
+    private translateUnaryExpression;
+    private translateWhere;
+    private translateExistsCondition;
+    private translatePatternCondition;
+    private translateInCondition;
+    private buildTimeWithOffsetOrderBy;
+    private buildDateTimeWithOffsetOrderBy;
+    private translateOrderByExpression;
+    /**
+     * Translate complex expressions for ORDER BY, substituting RETURN column aliases
+     */
+    private translateOrderByComplexExpression;
+    private translateWhereExpression;
+    /**
+     * Translate a function argument expression to SQL.
+     * Handles property access, literals, parameters, and variables.
+     */
+    private translateFunctionArg;
+    /**
+     * Check if a property name is a temporal accessor (like year, month, day, etc.)
+     * and return the SQL expression to extract it from a temporal value.
+     * Returns null if not a temporal accessor.
+     */
+    private translateTemporalPropertyAccess;
+    private isRelationshipPattern;
+    /**
+     * Generate SQL condition to match labels stored as JSON array.
+     * For a single label "Person", checks if label array contains "Person"
+     * For multiple labels ["A", "B"], checks if label array contains all of them
+     */
+    private generateLabelMatchCondition;
+    /**
+     * Normalize label to JSON array string for storage
+     */
+    private normalizeLabelToJson;
+    /**
+     * Quote an identifier for use as SQL alias (handles reserved words like FROM, TO)
+     */
+    private quoteAlias;
+    private expressionReferencesGraphVariables;
+    private findVariablesInExpression;
+    /**
+     * Extract the bound variables from a pattern comprehension expression.
+     * For pattern comprehensions like [p = (n)-->() | p], this returns ["n"]
+     * which is the variable from the outer context that the comprehension correlates with.
+     */
+    private getPatternComprehensionBoundVars;
+    /**
+     * Get the SQL expressions to use for GROUP BY when the given expression
+     * is used in an aggregation context. For pattern comprehensions, this returns
+     * the bound variable's identifier instead of the full correlated subquery.
+     */
+    private getGroupByKeys;
+    private findVariablesInCondition;
+    private isParameterRef;
+    /**
+     * Check if an expression contains a non-deterministic function (RAND, TIMESTAMP, etc.)
+     */
+    private containsNonDeterministicFunction;
+    /**
+     * Check if an expression is or contains an aggregate function (COUNT, SUM, AVG, MIN, MAX, COLLECT, PERCENTILEDISC, PERCENTILECONT)
+     */
+    private isAggregateExpression;
+    /**
+     * Extract list predicates from an expression that reference WITH aggregate aliases.
+     * Returns a set of alias names that need to be materialized.
+     */
+    private collectWithAggregateAliasesFromListPredicates;
+    /**
+     * Check if a WHERE condition references any alias that resolves to an aggregate expression.
+     * This is used to determine if the condition should go in HAVING instead of WHERE.
+     */
+    private whereConditionReferencesAggregateAlias;
+    private serializeProperties;
+    private isFunctionPropertyValue;
+    private isBinaryPropertyValue;
+    private isMapPropertyValue;
+    private evaluatePropertyValue;
+    private isVariableRef;
+    private evaluateExpression;
+    private getExpressionName;
+    /**
+     * Check for duplicate column names in RETURN or WITH items.
+     * Throws SyntaxError with ColumnNameConflict if duplicates are found.
+     */
+    private checkDuplicateColumnNames;
+    /**
+     * Validate that ORDER BY expressions with DISTINCT only reference columns in the RETURN clause.
+     * In SQL, when using SELECT DISTINCT, ORDER BY can only reference columns that appear in the SELECT list.
+     * This is because DISTINCT removes duplicate rows before ORDER BY, so ordering by a column not in
+     * the SELECT list would be ambiguous (which value to use from the deduplicated rows?).
+     *
+     * Special cases:
+     * - RETURN DISTINCT b ORDER BY b.name - VALID (b is returned, b.name is a property of b)
+     * - RETURN DISTINCT a.name ORDER BY a.age - INVALID (a.age is not in RETURN)
+     */
+    private validateDistinctOrderBy;
+    /**
+     * Validate ORDER BY with aggregation in RETURN.
+     * When aggregation is used, ORDER BY can only reference:
+     * - Column aliases from RETURN
+     * - Expressions that exactly match RETURN expressions
+     * - Pure aggregate expressions (no mixing of aggregate and non-aggregate)
+     *
+     * This prevents queries like:
+     * - RETURN count(you.age) ORDER BY me.age + count(you.age) - INVALID (me.age not grouped)
+     */
+    private validateAggregationOrderBy;
+    /**
+     * Check if an expression is a pure aggregate (contains only aggregates, literals, operators, and column aliases).
+     * No references to non-aggregated variables.
+     *
+     * @param expr - The expression to check
+     * @param availableColumns - Set of column aliases that are available from RETURN clause
+     * @param returnedExpressions - List of expressions in the RETURN clause
+     */
+    private isPureAggregateExpression;
+    /**
+     * Check if an expression matches any expression in the list (structurally).
+     */
+    private expressionMatchesAny;
+    /**
+     * Check if two expressions are structurally equivalent.
+     */
+    private expressionsMatch;
+    /**
+     * Translate temporal truncate functions: date.truncate(), datetime.truncate(), etc.
+     * Syntax: type.truncate(unit, temporal [, mapWithOverrides])
+     * Units: millennium, century, decade, year, weekYear, quarter, month, week, day, hour, minute, second, millisecond, microsecond
+     */
+    private translateTemporalTruncate;
+    private translateDateTruncate;
+    private translateDatetimeTruncate;
+    private translateLocaldatetimeTruncate;
+    private translateTimeTruncate;
+    private translateLocaltimeTruncate;
+    private generateId;
+}
+export declare function translate(query: Query, params?: Record<string, unknown>): TranslationResult;
+//# sourceMappingURL=translator.d.ts.map

package/dist/translator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"translator.d.ts","sourceRoot":"","sources":["../src/translator.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,EASL,UAAU,EAkBX,MAAM,aAAa,CAAC;AA2ErB,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,OAAO,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,iBAAiB;IAChC,UAAU,EAAE,YAAY,EAAE,CAAC;IAC3B,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED,MAAM,WAAW,kBAAkB;IAGjC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,eAAe,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,EAAE,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAE/H,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAErC,YAAY,EAAE,MAAM,CAAC;IAErB,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;CAC5B;AAMD,qBAAa,UAAU;IACrB,OAAO,CAAC,GAAG,CAAqB;gBAEpB,WAAW,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;IAQrD,SAAS,CAAC,KAAK,EAAE,KAAK,GAAG,iBAAiB;IA6C1C;;;OAGG;IACH,OAAO,CAAC,4BAA4B;IAmBpC,OAAO,CAAC,eAAe;IAmCvB,OAAO,CAAC,eAAe;IA2BvB,OAAO,CAAC,mBAAmB;IAwB3B,OAAO,CAAC,2BAA2B;IA8EnC,OAAO,CAAC,cAAc;IAqDtB,OAAO,CAAC,sBAAsB;IAuG9B,OAAO,CAAC,mBAAmB;IA4E3B,OAAO,CAAC,2BAA2B;IA0MnC,OAAO,CAAC,cAAc;IAoGtB,OAAO,CAAC,YAAY;IAoJpB,OAAO,CAAC,kCAAkC;IAsD1C;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAsBhC,OAAO,CAAC,eAAe;IA+CvB,OAAO,CAAC,eAAe;IAgCvB,OAAO,CAAC,eAAe;IA2nDvB,OAAO,CAAC,aAAa;IAiUrB,OAAO,CAAC,uBAAuB;IAuG/B,OAAO,CAAC,2BAA2B;IAy3BnC,OAAO,CAAC,cAAc;IAyCtB,OAAO,CAAC,eAAe;IAmGvB,OAAO,CAAC,aAAa;IA6DrB,OAAO,CAAC,kBAAkB;IAsD1B,OAAO,CAAC,0BAA0B;IAwClC,OAAO,CAAC,yBAAyB;IAiBjC,OAAO,CAAC,mBAAmB;IAghK3B,OAAO,CAAC,uBAAuB;IAoE/B;;OAEG;IACH,OAAO,CAAC,0BAA0B;IAkDlC,OAAO,CAAC,yBAAyB;IA2KjC,OAAO,CAAC,sCAAsC;IAigB9C,OAAO,CAAC,gBAAgB;IAkDxB,OAAO,CAAC,kBAAkB;IA4B1B,OAAO,CAAC,qBAAqB;IAkB7B;;;;OAIG;IACH,OAAO,CAAC,eAAe;IAYvB,OAAO,CAAC,YAAY;IAWpB,OAAO,CAAC,iBAAiB;IAYzB;;;OAGG;IACH,OAAO,CAAC,iCAAiC;IA4DzC,OAAO,CAAC,4BAA4B;IAqBpC,OAAO,CAAC,6BAA6B;IASrC,OAAO,CAAC,6BAA6B;IA8JrC,OAAO,CAAC,iBAAiB;IAWzB,OAAO,CAAC,sBAAsB;IA4B9B,OAAO,CAAC,qBAAqB;IAyC7B;;;;;;OAMG;IACH,OAAO,CAAC,0BAA0B;IAkDlC;;;;;;;;OAQG;IACH,OAAO,CAAC,6BAA6B;IA2KrC;;OAEG;IACH,OAAO,CAAC,iCAAiC;IAiEzC;;OAEG;IACH,OAAO,CAAC,sCAAsC;IAgD9C;;;;OAIG;IACH,OAAO,CAAC,8BAA8B;IA4HtC;;;OAGG;IACH,OAAO,CAAC,mCAAmC;IAuG3C;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,sBAAsB;IA4F9B;;;;;;;OAOG;IACH,OAAO,CAAC,4BAA4B;IAyEpC;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAa5B;;;OAGG;IACH,OAAO,CAAC,uBAAuB;IAqE/B;;;OAGG;IACH,OAAO,CAAC,sBAAsB;IAW9B;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IA6B1B;;;OAGG;IACH,OAAO,CAAC,iCAAiC;IAqBzC;;;OAGG;IACH,OAAO,CAAC,kCAAkC;IA2B1C;;OAEG;IACH,OAAO,CAAC,4BAA4B;IAsBpC;;;OAGG;IACH,OAAO,CAAC,0BAA0B;IAiBlC;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAuBhC,OAAO,CAAC,cAAc;IAuKtB,OAAO,CAAC,wBAAwB;IAwE/B,OAAO,CAAC,yBAAyB;IAgRjC,OAAO,CAAC,oBAAoB;IA6E7B,OAAO,CAAC,0BAA0B;IA2BlC,OAAO,CAAC,8BAA8B;IA6BtC,OAAO,CAAC,0BAA0B;IA8KlC;;OAEG;IACH,OAAO,CAAC,iCAAiC;IA6FzC,OAAO,CAAC,wBAAwB;IAuKhC;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAuH5B;;;;OAIG;IACH,OAAO,CAAC,+BAA+B;IAiHvC,OAAO,CAAC,qBAAqB;IAI7B;;;;OAIG;IACH,OAAO,CAAC,2BAA2B;IAsBnC;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAQ5B;;OAEG;IACH,OAAO,CAAC,UAAU;IAKlB,OAAO,CAAC,kCAAkC;IAyB1C,OAAO,CAAC,yBAAyB;IAyEjC;;;;OAIG;IACH,OAAO,CAAC,gCAAgC;IA6BxC;;;;OAIG;IACH,OAAO,CAAC,cAAc;IA2BtB,OAAO,CAAC,wBAAwB;IAgChC,OAAO,CAAC,cAAc;IAItB;;OAEG;IACH,OAAO,CAAC,gCAAgC;IAsBxC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IA4B7B;;;OAGG;IACH,OAAO,CAAC,6CAA6C;IAiDrD;;;OAGG;IACH,OAAO,CAAC,sCAAsC;IAgD9C,OAAO,CAAC,mBAAmB;IA6D3B,OAAO,CAAC,uBAAuB;IAY/B,OAAO,CAAC,qBAAqB;IAa7B,OAAO,CAAC,kBAAkB;IAY1B,OAAO,CAAC,qBAAqB;IAkQ7B,OAAO,CAAC,aAAa;IAMrB,OAAO,CAAC,kBAAkB;IAW1B,OAAO,CAAC,iBAAiB;IAkFzB;;;OAGG;IACH,OAAO,CAAC,yBAAyB;IAoBjC;;;;;;;;;OASG;IACH,OAAO,CAAC,uBAAuB;IAiD/B;;;;;;;;;OASG;IACH,OAAO,CAAC,0BAA0B;IAqClC;;;;;;;OAOG;IACH,OAAO,CAAC,yBAAyB;IA0CjC;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAS5B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAwBxB;;;;OAIG;IACH,OAAO,CAAC,yBAAyB;IAwFjC,OAAO,CAAC,qBAAqB;IAoF7B,OAAO,CAAC,yBAAyB;IAwMjC,OAAO,CAAC,8BAA8B;IAmKtC,OAAO,CAAC,qBAAqB;IA8J7B,OAAO,CAAC,0BAA0B;IAsHlC,OAAO,CAAC,UAAU;CAGnB;AAGD,wBAAgB,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAAG,iBAAiB,CAE/F"}