@devrev/meerkat-core 0.0.97 → 0.0.98

package/src/cube-filter-transformer/factory.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cubeFilterToDuckdbAST = void 0;
+const type_guards_1 = require("../utils/type-guards");
+const and_1 = require("./and/and");
+const contains_1 = require("./contains/contains");
+const equals_1 = require("./equals/equals");
+const gt_1 = require("./gt/gt");
+const gte_1 = require("./gte/gte");
+const in_date_range_1 = require("./in-date-range/in-date-range");
+const in_1 = require("./in/in");
+const lt_1 = require("./lt/lt");
+const lte_1 = require("./lte/lte");
+const not_In_date_range_1 = require("./not-In-date-range/not-In-date-range");
+const not_contains_1 = require("./not-contains/not-contains");
+const not_equals_1 = require("./not-equals/not-equals");
+const not_in_1 = require("./not-in/not-in");
+const not_set_1 = require("./not-set/not-set");
+const or_1 = require("./or/or");
+const set_1 = require("./set/set");
+// Comparison operators
+const cubeFilterOperatorsToDuckdb = (cubeFilter) => {
+    switch (cubeFilter.operator) {
+        case 'equals':
+            return (0, equals_1.equalsTransform)(cubeFilter);
+        case 'notEquals':
+            return (0, not_equals_1.notEqualsTransform)(cubeFilter);
+        case 'in':
+            return (0, in_1.inTransform)(cubeFilter);
+        case 'notIn':
+            return (0, not_in_1.notInTransform)(cubeFilter);
+        case 'contains':
+            return (0, contains_1.containsTransform)(cubeFilter);
+        case 'notContains':
+            return (0, not_contains_1.notContainsTransform)(cubeFilter);
+        case 'gt':
+            return (0, gt_1.gtTransform)(cubeFilter);
+        case 'gte':
+            return (0, gte_1.gteTransform)(cubeFilter);
+        case 'lt':
+            return (0, lt_1.ltTransform)(cubeFilter);
+        case 'lte':
+            return (0, lte_1.lteTransform)(cubeFilter);
+        case 'inDateRange':
+            return (0, in_date_range_1.inDataRangeTransform)(cubeFilter);
+        case 'notInDateRange':
+            return (0, not_In_date_range_1.notInDataRangeTransform)(cubeFilter);
+        case 'notSet': {
+            return (0, not_set_1.notSetTransform)(cubeFilter);
+        }
+        case 'set': {
+            return (0, set_1.setTransform)(cubeFilter);
+        }
+        default:
+            throw new Error('Could not transform the filter');
+    }
+};
+const cubeFilterLogicalAndOrToDuckdb = (cubeFilter, whereObj) => {
+    /**
+     * This condition is true when you are at the leaf most level of the filter
+     */
+    if (!(0, type_guards_1.isFilterArray)(cubeFilter) && (0, type_guards_1.isQueryFilter)(cubeFilter)) {
+        const data = cubeFilterOperatorsToDuckdb(cubeFilter);
+        if (!data) {
+            throw new Error('Could not transform the filter');
+        }
+        return data;
+    }
+    if (!(0, type_guards_1.isFilterArray)(cubeFilter) && (0, type_guards_1.isLogicalAnd)(cubeFilter)) {
+        if (cubeFilter.and.length === 0) {
+            return null;
+        }
+        // And or Or we need to recurse
+        const andDuckdbExpression = (0, and_1.andDuckdbCondition)();
+        const data = cubeFilterLogicalAndOrToDuckdb(cubeFilter.and, andDuckdbExpression);
+        return data;
+    }
+    if (!(0, type_guards_1.isFilterArray)(cubeFilter) && (0, type_guards_1.isLogicalOr)(cubeFilter)) {
+        if (cubeFilter.or.length === 0) {
+            return null;
+        }
+        // And or Or we need to recurse
+        const orDuckdbExpression = (0, or_1.orDuckdbCondition)();
+        const data = cubeFilterLogicalAndOrToDuckdb(cubeFilter.or, orDuckdbExpression);
+        return data;
+    }
+    if ((0, type_guards_1.isFilterArray)(cubeFilter)) {
+        for (const filter of cubeFilter) {
+            const data = cubeFilterLogicalAndOrToDuckdb(filter, whereObj);
+            if (data) {
+                if ((0, type_guards_1.hasChildren)(whereObj)) {
+                    whereObj.children.push(data);
+                }
+                else {
+                    whereObj = data;
+                }
+            }
+        }
+        return whereObj;
+    }
+    return whereObj;
+};
+const cubeFilterToDuckdbAST = (cubeFilter, ast) => {
+    let whereObj = ast.node.where_clause || null;
+    if (cubeFilter.length > 1) {
+        console.error('We do not support multiple filters yet');
+        throw new Error('We do not support multiple filters yet');
+    }
+    const filter = cubeFilter[0];
+    if ((0, type_guards_1.isQueryFilter)(filter)) {
+        whereObj = cubeFilterOperatorsToDuckdb(filter);
+    }
+    if ((0, type_guards_1.isLogicalAndOR)(filter)) {
+        // And or Or we need to recurse
+        whereObj = cubeFilterLogicalAndOrToDuckdb(filter, whereObj || null);
+    }
+    return whereObj;
+};
+exports.cubeFilterToDuckdbAST = cubeFilterToDuckdbAST;
+//# sourceMappingURL=factory.js.map

package/src/cube-filter-transformer/factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.js","sourceRoot":"","sources":["../../../../meerkat-core/src/cube-filter-transformer/factory.ts"],"names":[],"mappings":"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"}

package/src/cube-filter-transformer/gt/gt.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gtTransform = void 0;
+const Expression_1 = require("../../types/duckdb-serialization-types/serialization/Expression");
+const base_condition_builder_1 = require("../base-condition-builder/base-condition-builder");
+const or_1 = require("../or/or");
+const gtTransform = (query) => {
+    const { member, values } = query;
+    if (!values || values.length === 0) {
+        throw new Error('GT filter must have at least one value');
+    }
+    /**
+     * If there is only one value, we can create a simple equals condition
+     */
+    if (values.length === 1) {
+        return (0, base_condition_builder_1.baseDuckdbCondition)(member, Expression_1.ExpressionType.COMPARE_GREATERTHAN, values[0], query.memberInfo);
+    }
+    /**
+     * If there are multiple values, we need to create an OR condition
+     */
+    const orCondition = (0, or_1.orDuckdbCondition)();
+    values.forEach((value) => {
+        orCondition.children.push((0, base_condition_builder_1.baseDuckdbCondition)(member, Expression_1.ExpressionType.COMPARE_GREATERTHAN, value, query.memberInfo));
+    });
+    return orCondition;
+};
+exports.gtTransform = gtTransform;
+//# sourceMappingURL=gt.js.map

package/src/cube-filter-transformer/gt/gt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gt.js","sourceRoot":"","sources":["../../../../../meerkat-core/src/cube-filter-transformer/gt/gt.ts"],"names":[],"mappings":";;;AAAA,gGAAiG;AACjG,6FAAuF;AAEvF,iCAA6C;AAEtC,MAAM,WAAW,GAAmC,CAAC,KAAK,EAAE,EAAE;IACnE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC;IAEjC,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE;QAClC,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;KAC3D;IAED;;OAEG;IACH,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE;QACvB,OAAO,IAAA,4CAAmB,EACxB,MAAM,EACN,2BAAc,CAAC,mBAAmB,EAClC,MAAM,CAAC,CAAC,CAAC,EACT,KAAK,CAAC,UAAU,CACjB,CAAC;KACH;IAED;;OAEG;IACH,MAAM,WAAW,GAAG,IAAA,sBAAiB,GAAE,CAAC;IACxC,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;QACvB,WAAW,CAAC,QAAQ,CAAC,IAAI,CACvB,IAAA,4CAAmB,EACjB,MAAM,EACN,2BAAc,CAAC,mBAAmB,EAClC,KAAK,EACL,KAAK,CAAC,UAAU,CACjB,CACF,CAAC;IACJ,CAAC,CAAC,CAAC;IACH,OAAO,WAAW,CAAC;AACrB,CAAC,CAAC;AAlCW,QAAA,WAAW,eAkCtB"}

package/src/cube-filter-transformer/gte/gte.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gteTransform = void 0;
+const Expression_1 = require("../../types/duckdb-serialization-types/serialization/Expression");
+const base_condition_builder_1 = require("../base-condition-builder/base-condition-builder");
+const or_1 = require("../or/or");
+const gteTransform = (query) => {
+    const { member, values } = query;
+    if (!values || values.length === 0) {
+        throw new Error('GTE filter must have at least one value');
+    }
+    /**
+     * If there is only one value, we can create a simple equals condition
+     */
+    if (values.length === 1) {
+        return (0, base_condition_builder_1.baseDuckdbCondition)(member, Expression_1.ExpressionType.COMPARE_GREATERTHANOREQUALTO, values[0], query.memberInfo);
+    }
+    /**
+     * If there are multiple values, we need to create an OR condition
+     */
+    const orCondition = (0, or_1.orDuckdbCondition)();
+    values.forEach((value) => {
+        orCondition.children.push((0, base_condition_builder_1.baseDuckdbCondition)(member, Expression_1.ExpressionType.COMPARE_GREATERTHANOREQUALTO, value, query.memberInfo));
+    });
+    return orCondition;
+};
+exports.gteTransform = gteTransform;
+//# sourceMappingURL=gte.js.map

package/src/cube-filter-transformer/gte/gte.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gte.js","sourceRoot":"","sources":["../../../../../meerkat-core/src/cube-filter-transformer/gte/gte.ts"],"names":[],"mappings":";;;AAAA,gGAAiG;AACjG,6FAAuF;AAEvF,iCAA6C;AAEtC,MAAM,YAAY,GAAmC,CAAC,KAAK,EAAE,EAAE;IACpE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC;IAEjC,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE;QAClC,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;KAC5D;IAED;;OAEG;IACH,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE;QACvB,OAAO,IAAA,4CAAmB,EACxB,MAAM,EACN,2BAAc,CAAC,4BAA4B,EAC3C,MAAM,CAAC,CAAC,CAAC,EACT,KAAK,CAAC,UAAU,CACjB,CAAC;KACH;IAED;;OAEG;IACH,MAAM,WAAW,GAAG,IAAA,sBAAiB,GAAE,CAAC;IACxC,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;QACvB,WAAW,CAAC,QAAQ,CAAC,IAAI,CACvB,IAAA,4CAAmB,EACjB,MAAM,EACN,2BAAc,CAAC,4BAA4B,EAC3C,KAAK,EACL,KAAK,CAAC,UAAU,CACjB,CACF,CAAC;IACJ,CAAC,CAAC,CAAC;IACH,OAAO,WAAW,CAAC;AACrB,CAAC,CAAC;AAlCW,QAAA,YAAY,gBAkCvB"}

package/src/cube-filter-transformer/in/in.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inTransform = void 0;
+const constants_1 = require("../../member-formatters/constants");
+const Expression_1 = require("../../types/duckdb-serialization-types/serialization/Expression");
+const base_condition_builder_1 = require("../base-condition-builder/base-condition-builder");
+const inDuckDbCondition = (columnName, values, memberInfo) => {
+    const sqlTreeValues = values.map((value) => {
+        return {
+            class: Expression_1.ExpressionClass.CONSTANT,
+            type: Expression_1.ExpressionType.VALUE_CONSTANT,
+            alias: '',
+            value: (0, base_condition_builder_1.valueBuilder)(value, memberInfo),
+        };
+    });
+    const columnRef = {
+        class: 'COLUMN_REF',
+        type: 'COLUMN_REF',
+        alias: '',
+        column_names: columnName.split(constants_1.COLUMN_NAME_DELIMITER),
+    };
+    switch (memberInfo.type) {
+        case 'number_array':
+        case 'string_array': {
+            return {
+                class: Expression_1.ExpressionClass.FUNCTION,
+                type: Expression_1.ExpressionType.FUNCTION,
+                alias: '',
+                function_name: '&&',
+                schema: '',
+                children: [
+                    columnRef,
+                    {
+                        class: Expression_1.ExpressionClass.OPERATOR,
+                        type: Expression_1.ExpressionType.ARRAY_CONSTRUCTOR,
+                        alias: '',
+                        children: sqlTreeValues,
+                    },
+                ],
+                filter: null,
+                order_bys: {
+                    type: 'ORDER_MODIFIER',
+                    orders: [],
+                },
+                distinct: false,
+                is_operator: true,
+                export_state: false,
+                catalog: '',
+            };
+        }
+        default: {
+            return {
+                class: Expression_1.ExpressionClass.OPERATOR,
+                type: Expression_1.ExpressionType.COMPARE_IN,
+                alias: '',
+                children: [columnRef, ...sqlTreeValues],
+            };
+        }
+    }
+};
+const inTransform = (query) => {
+    const { member, values, memberInfo } = query;
+    if (!values) {
+        throw new Error('In filter must have at least one value');
+    }
+    return inDuckDbCondition(member, values, memberInfo);
+};
+exports.inTransform = inTransform;
+//# sourceMappingURL=in.js.map

package/src/cube-filter-transformer/in/in.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"in.js","sourceRoot":"","sources":["../../../../../meerkat-core/src/cube-filter-transformer/in/in.ts"],"names":[],"mappings":";;;AAAA,iEAA0E;AAE1E,gGAGyE;AACzE,6FAAgF;AAGhF,MAAM,iBAAiB,GAAG,CACxB,UAAkB,EAClB,MAAgB,EAChB,UAA+B,EAC/B,EAAE;IACF,MAAM,aAAa,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;QACzC,OAAO;YACL,KAAK,EAAE,4BAAe,CAAC,QAAQ;YAC/B,IAAI,EAAE,2BAAc,CAAC,cAAc;YACnC,KAAK,EAAE,EAAE;YACT,KAAK,EAAE,IAAA,qCAAY,EAAC,KAAK,EAAE,UAAU,CAAC;SACvC,CAAC;IACJ,CAAC,CAAC,CAAC;IACH,MAAM,SAAS,GAAG;QAChB,KAAK,EAAE,YAAY;QACnB,IAAI,EAAE,YAAY;QAClB,KAAK,EAAE,EAAE;QACT,YAAY,EAAE,UAAU,CAAC,KAAK,CAAC,iCAAqB,CAAC;KACtD,CAAC;IACF,QAAQ,UAAU,CAAC,IAAI,EAAE;QACvB,KAAK,cAAc,CAAC;QACpB,KAAK,cAAc,CAAC,CAAC;YACnB,OAAO;gBACL,KAAK,EAAE,4BAAe,CAAC,QAAQ;gBAC/B,IAAI,EAAE,2BAAc,CAAC,QAAQ;gBAC7B,KAAK,EAAE,EAAE;gBACT,aAAa,EAAE,IAAI;gBACnB,MAAM,EAAE,EAAE;gBACV,QAAQ,EAAE;oBACR,SAAS;oBACT;wBACE,KAAK,EAAE,4BAAe,CAAC,QAAQ;wBAC/B,IAAI,EAAE,2BAAc,CAAC,iBAAiB;wBACtC,KAAK,EAAE,EAAE;wBACT,QAAQ,EAAE,aAAa;qBACxB;iBACF;gBACD,MAAM,EAAE,IAAI;gBACZ,SAAS,EAAE;oBACT,IAAI,EAAE,gBAAgB;oBACtB,MAAM,EAAE,EAAE;iBACX;gBACD,QAAQ,EAAE,KAAK;gBACf,WAAW,EAAE,IAAI;gBACjB,YAAY,EAAE,KAAK;gBACnB,OAAO,EAAE,EAAE;aACZ,CAAC;SACH;QACD,OAAO,CAAC,CAAC;YACP,OAAO;gBACL,KAAK,EAAE,4BAAe,CAAC,QAAQ;gBAC/B,IAAI,EAAE,2BAAc,CAAC,UAAU;gBAC/B,KAAK,EAAE,EAAE;gBACT,QAAQ,EAAE,CAAC,SAAS,EAAE,GAAG,aAAa,CAAC;aACxC,CAAC;SACH;KACF;AACH,CAAC,CAAC;AAEK,MAAM,WAAW,GAAmC,CAAC,KAAK,EAAE,EAAE;IACnE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,KAAK,CAAC;IAC7C,IAAI,CAAC,MAAM,EAAE;QACX,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;KAC3D;IACD,OAAO,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC;AACvD,CAAC,CAAC;AANW,QAAA,WAAW,eAMtB"}

package/src/cube-filter-transformer/in-date-range/in-date-range.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inDataRangeTransform = void 0;
+const Expression_1 = require("../../types/duckdb-serialization-types/serialization/Expression");
+const and_1 = require("../and/and");
+const base_condition_builder_1 = require("../base-condition-builder/base-condition-builder");
+const inDataRangeTransform = (query) => {
+    const { member, values } = query;
+    if (!values || values.length === 0) {
+        throw new Error('GT filter must have at least one value');
+    }
+    /**
+     * If there are multiple values, we need to create an OR condition
+     */
+    const andCondition = (0, and_1.andDuckdbCondition)();
+    andCondition.children.push((0, base_condition_builder_1.baseDuckdbCondition)(member, Expression_1.ExpressionType.COMPARE_GREATERTHANOREQUALTO, values[0], query.memberInfo));
+    andCondition.children.push((0, base_condition_builder_1.baseDuckdbCondition)(member, Expression_1.ExpressionType.COMPARE_LESSTHANOREQUALTO, values[1], query.memberInfo));
+    return andCondition;
+};
+exports.inDataRangeTransform = inDataRangeTransform;
+//# sourceMappingURL=in-date-range.js.map

package/src/cube-filter-transformer/in-date-range/in-date-range.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-date-range.js","sourceRoot":"","sources":["../../../../../meerkat-core/src/cube-filter-transformer/in-date-range/in-date-range.ts"],"names":[],"mappings":";;;AAAA,gGAAiG;AACjG,oCAAgD;AAChD,6FAAuF;AAGhF,MAAM,oBAAoB,GAAmC,CAAC,KAAK,EAAE,EAAE;IAC5E,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC;IAEjC,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE;QAClC,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;KAC3D;IAED;;OAEG;IACH,MAAM,YAAY,GAAG,IAAA,wBAAkB,GAAE,CAAC;IAE1C,YAAY,CAAC,QAAQ,CAAC,IAAI,CACxB,IAAA,4CAAmB,EACjB,MAAM,EACN,2BAAc,CAAC,4BAA4B,EAC3C,MAAM,CAAC,CAAC,CAAC,EACT,KAAK,CAAC,UAAU,CACjB,CACF,CAAC;IAEF,YAAY,CAAC,QAAQ,CAAC,IAAI,CACxB,IAAA,4CAAmB,EACjB,MAAM,EACN,2BAAc,CAAC,yBAAyB,EACxC,MAAM,CAAC,CAAC,CAAC,EACT,KAAK,CAAC,UAAU,CACjB,CACF,CAAC;IAEF,OAAO,YAAY,CAAC;AACtB,CAAC,CAAC;AA/BW,QAAA,oBAAoB,wBA+B/B"}

package/src/cube-filter-transformer/lt/lt.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ltTransform = void 0;
+const Expression_1 = require("../../types/duckdb-serialization-types/serialization/Expression");
+const base_condition_builder_1 = require("../base-condition-builder/base-condition-builder");
+const or_1 = require("../or/or");
+const ltTransform = (query) => {
+    const { member, values } = query;
+    if (!values || values.length === 0) {
+        throw new Error('lt filter must have at least one value');
+    }
+    /**
+     * If there is only one value, we can create a simple equals condition
+     */
+    if (values.length === 1) {
+        return (0, base_condition_builder_1.baseDuckdbCondition)(member, Expression_1.ExpressionType.COMPARE_LESSTHAN, values[0], query.memberInfo);
+    }
+    /**
+     * If there are multiple values, we need to create an OR condition
+     */
+    const orCondition = (0, or_1.orDuckdbCondition)();
+    values.forEach((value) => {
+        orCondition.children.push((0, base_condition_builder_1.baseDuckdbCondition)(member, Expression_1.ExpressionType.COMPARE_LESSTHAN, value, query.memberInfo));
+    });
+    return orCondition;
+};
+exports.ltTransform = ltTransform;
+//# sourceMappingURL=lt.js.map

package/src/cube-filter-transformer/lt/lt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lt.js","sourceRoot":"","sources":["../../../../../meerkat-core/src/cube-filter-transformer/lt/lt.ts"],"names":[],"mappings":";;;AAAA,gGAAiG;AACjG,6FAAuF;AAEvF,iCAA6C;AAEtC,MAAM,WAAW,GAAmC,CAAC,KAAK,EAAE,EAAE;IACnE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC;IAEjC,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE;QAClC,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;KAC3D;IAED;;OAEG;IACH,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE;QACvB,OAAO,IAAA,4CAAmB,EACxB,MAAM,EACN,2BAAc,CAAC,gBAAgB,EAC/B,MAAM,CAAC,CAAC,CAAC,EACT,KAAK,CAAC,UAAU,CACjB,CAAC;KACH;IAED;;OAEG;IACH,MAAM,WAAW,GAAG,IAAA,sBAAiB,GAAE,CAAC;IACxC,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;QACvB,WAAW,CAAC,QAAQ,CAAC,IAAI,CACvB,IAAA,4CAAmB,EACjB,MAAM,EACN,2BAAc,CAAC,gBAAgB,EAC/B,KAAK,EACL,KAAK,CAAC,UAAU,CACjB,CACF,CAAC;IACJ,CAAC,CAAC,CAAC;IACH,OAAO,WAAW,CAAC;AACrB,CAAC,CAAC;AAlCW,QAAA,WAAW,eAkCtB"}

package/src/cube-filter-transformer/lte/lte.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lteTransform = void 0;
+const Expression_1 = require("../../types/duckdb-serialization-types/serialization/Expression");
+const base_condition_builder_1 = require("../base-condition-builder/base-condition-builder");
+const or_1 = require("../or/or");
+const lteTransform = (query) => {
+    const { member, values } = query;
+    if (!values || values.length === 0) {
+        throw new Error('lte filter must have at least one value');
+    }
+    /**
+     * If there is only one value, we can create a simple equals condition
+     */
+    if (values.length === 1) {
+        return (0, base_condition_builder_1.baseDuckdbCondition)(member, Expression_1.ExpressionType.COMPARE_LESSTHANOREQUALTO, values[0], query.memberInfo);
+    }
+    /**
+     * If there are multiple values, we need to create an OR condition
+     */
+    const orCondition = (0, or_1.orDuckdbCondition)();
+    values.forEach((value) => {
+        orCondition.children.push((0, base_condition_builder_1.baseDuckdbCondition)(member, Expression_1.ExpressionType.COMPARE_LESSTHANOREQUALTO, value, query.memberInfo));
+    });
+    return orCondition;
+};
+exports.lteTransform = lteTransform;
+//# sourceMappingURL=lte.js.map

package/src/cube-filter-transformer/lte/lte.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lte.js","sourceRoot":"","sources":["../../../../../meerkat-core/src/cube-filter-transformer/lte/lte.ts"],"names":[],"mappings":";;;AAAA,gGAAiG;AACjG,6FAAuF;AAEvF,iCAA6C;AAEtC,MAAM,YAAY,GAAmC,CAAC,KAAK,EAAE,EAAE;IACpE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC;IAEjC,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE;QAClC,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;KAC5D;IAED;;OAEG;IACH,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE;QACvB,OAAO,IAAA,4CAAmB,EACxB,MAAM,EACN,2BAAc,CAAC,yBAAyB,EACxC,MAAM,CAAC,CAAC,CAAC,EACT,KAAK,CAAC,UAAU,CACjB,CAAC;KACH;IAED;;OAEG;IACH,MAAM,WAAW,GAAG,IAAA,sBAAiB,GAAE,CAAC;IACxC,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;QACvB,WAAW,CAAC,QAAQ,CAAC,IAAI,CACvB,IAAA,4CAAmB,EACjB,MAAM,EACN,2BAAc,CAAC,yBAAyB,EACxC,KAAK,EACL,KAAK,CAAC,UAAU,CACjB,CACF,CAAC;IACJ,CAAC,CAAC,CAAC;IACH,OAAO,WAAW,CAAC;AACrB,CAAC,CAAC;AAlCW,QAAA,YAAY,gBAkCvB"}

package/src/cube-filter-transformer/not/not.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notDuckdbCondition = void 0;
+const index_1 = require("../../types/duckdb-serialization-types/index");
+const notDuckdbCondition = () => {
+    return {
+        class: index_1.ExpressionClass.OPERATOR,
+        type: index_1.ExpressionType.OPERATOR_NOT,
+        alias: '',
+        children: [],
+    };
+};
+exports.notDuckdbCondition = notDuckdbCondition;
+//# sourceMappingURL=not.js.map

package/src/cube-filter-transformer/not/not.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"not.js","sourceRoot":"","sources":["../../../../../meerkat-core/src/cube-filter-transformer/not/not.ts"],"names":[],"mappings":";;;AAAA,wEAIsD;AAE/C,MAAM,kBAAkB,GAAG,GAAuB,EAAE;IACzD,OAAO;QACL,KAAK,EAAE,uBAAe,CAAC,QAAQ;QAC/B,IAAI,EAAE,sBAAc,CAAC,YAAY;QACjC,KAAK,EAAE,EAAE;QACT,QAAQ,EAAE,EAAE;KACb,CAAC;AACJ,CAAC,CAAC;AAPW,QAAA,kBAAkB,sBAO7B"}

package/src/cube-filter-transformer/not-In-date-range/not-In-date-range.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notInDataRangeTransform = void 0;
+const Expression_1 = require("../../types/duckdb-serialization-types/serialization/Expression");
+const base_condition_builder_1 = require("../base-condition-builder/base-condition-builder");
+const or_1 = require("../or/or");
+const notInDataRangeTransform = (query) => {
+    const { member, values } = query;
+    if (!values || values.length === 0) {
+        throw new Error('GT filter must have at least one value');
+    }
+    /**
+     * If there are multiple values, we need to create an OR condition
+     */
+    const andCondition = (0, or_1.orDuckdbCondition)();
+    andCondition.children.push((0, base_condition_builder_1.baseDuckdbCondition)(member, Expression_1.ExpressionType.COMPARE_LESSTHAN, values[0], query.memberInfo));
+    andCondition.children.push((0, base_condition_builder_1.baseDuckdbCondition)(member, Expression_1.ExpressionType.COMPARE_GREATERTHAN, values[1], query.memberInfo));
+    return andCondition;
+};
+exports.notInDataRangeTransform = notInDataRangeTransform;
+//# sourceMappingURL=not-In-date-range.js.map

package/src/cube-filter-transformer/not-In-date-range/not-In-date-range.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"not-In-date-range.js","sourceRoot":"","sources":["../../../../../meerkat-core/src/cube-filter-transformer/not-In-date-range/not-In-date-range.ts"],"names":[],"mappings":";;;AAAA,gGAAiG;AACjG,6FAAuF;AAEvF,iCAA6C;AAEtC,MAAM,uBAAuB,GAAmC,CACrE,KAAK,EACL,EAAE;IACF,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC;IAEjC,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE;QAClC,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;KAC3D;IAED;;OAEG;IACH,MAAM,YAAY,GAAG,IAAA,sBAAiB,GAAE,CAAC;IAEzC,YAAY,CAAC,QAAQ,CAAC,IAAI,CACxB,IAAA,4CAAmB,EACjB,MAAM,EACN,2BAAc,CAAC,gBAAgB,EAC/B,MAAM,CAAC,CAAC,CAAC,EACT,KAAK,CAAC,UAAU,CACjB,CACF,CAAC;IAEF,YAAY,CAAC,QAAQ,CAAC,IAAI,CACxB,IAAA,4CAAmB,EACjB,MAAM,EACN,2BAAc,CAAC,mBAAmB,EAClC,MAAM,CAAC,CAAC,CAAC,EACT,KAAK,CAAC,UAAU,CACjB,CACF,CAAC;IAEF,OAAO,YAAY,CAAC;AACtB,CAAC,CAAC;AAjCW,QAAA,uBAAuB,2BAiClC"}

package/src/cube-filter-transformer/not-contains/not-contains.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notContainsTransform = exports.notContainsDuckdbCondition = void 0;
+const constants_1 = require("../../member-formatters/constants");
+const Expression_1 = require("../../types/duckdb-serialization-types/serialization/Expression");
+const base_condition_builder_1 = require("../base-condition-builder/base-condition-builder");
+const or_1 = require("../or/or");
+const notContainsDuckdbCondition = (columnName, value, memberInfo) => {
+    return {
+        class: Expression_1.ExpressionClass.FUNCTION,
+        type: Expression_1.ExpressionType.FUNCTION,
+        alias: '',
+        function_name: '!~~',
+        schema: '',
+        children: [
+            {
+                class: 'COLUMN_REF',
+                type: 'COLUMN_REF',
+                alias: '',
+                column_names: columnName.split(constants_1.COLUMN_NAME_DELIMITER),
+            },
+            {
+                class: 'CONSTANT',
+                type: 'VALUE_CONSTANT',
+                alias: '',
+                value: (0, base_condition_builder_1.valueBuilder)(`%${value}%`, memberInfo),
+            },
+        ],
+        filter: null,
+        order_bys: {
+            type: 'ORDER_MODIFIER',
+            orders: [],
+        },
+        distinct: false,
+        is_operator: true,
+        export_state: false,
+        catalog: '',
+    };
+};
+exports.notContainsDuckdbCondition = notContainsDuckdbCondition;
+const notContainsTransform = (query) => {
+    const { member, values, memberInfo } = query;
+    if (!values || values.length === 0) {
+        throw new Error('Contains filter must have at least one value');
+    }
+    /**
+     * If there is only one value, we can create a simple Contains condition
+     */
+    if (values.length === 1) {
+        return (0, exports.notContainsDuckdbCondition)(member, values[0], memberInfo);
+    }
+    /**
+     * If there are multiple values, we need to create an OR condition
+     */
+    const orCondition = (0, or_1.orDuckdbCondition)();
+    values.forEach((value) => {
+        orCondition.children.push((0, exports.notContainsDuckdbCondition)(member, value, memberInfo));
+    });
+    return orCondition;
+};
+exports.notContainsTransform = notContainsTransform;
+//# sourceMappingURL=not-contains.js.map

package/src/cube-filter-transformer/not-contains/not-contains.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"not-contains.js","sourceRoot":"","sources":["../../../../../meerkat-core/src/cube-filter-transformer/not-contains/not-contains.ts"],"names":[],"mappings":";;;AAAA,iEAA0E;AAG1E,gGAGyE;AACzE,6FAAgF;AAEhF,iCAA6C;AAQtC,MAAM,0BAA0B,GAAG,CACxC,UAAkB,EAClB,KAAa,EACb,UAA+B,EAC/B,EAAE;IACF,OAAO;QACL,KAAK,EAAE,4BAAe,CAAC,QAAQ;QAC/B,IAAI,EAAE,2BAAc,CAAC,QAAQ;QAC7B,KAAK,EAAE,EAAE;QACT,aAAa,EAAE,KAAK;QACpB,MAAM,EAAE,EAAE;QACV,QAAQ,EAAE;YACR;gBACE,KAAK,EAAE,YAAY;gBACnB,IAAI,EAAE,YAAY;gBAClB,KAAK,EAAE,EAAE;gBACT,YAAY,EAAE,UAAU,CAAC,KAAK,CAAC,iCAAqB,CAAC;aACtD;YACD;gBACE,KAAK,EAAE,UAAU;gBACjB,IAAI,EAAE,gBAAgB;gBACtB,KAAK,EAAE,EAAE;gBACT,KAAK,EAAE,IAAA,qCAAY,EAAC,IAAI,KAAK,GAAG,EAAE,UAAU,CAAC;aAC9C;SACF;QACD,MAAM,EAAE,IAAI;QACZ,SAAS,EAAE;YACT,IAAI,EAAE,gBAAgB;YACtB,MAAM,EAAE,EAAE;SACX;QACD,QAAQ,EAAE,KAAK;QACf,WAAW,EAAE,IAAI;QACjB,YAAY,EAAE,KAAK;QACnB,OAAO,EAAE,EAAE;KACZ,CAAC;AACJ,CAAC,CAAC;AAnCW,QAAA,0BAA0B,8BAmCrC;AAEK,MAAM,oBAAoB,GAAmC,CAAC,KAAK,EAAE,EAAE;IAC5E,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,KAAK,CAAC;IAE7C,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE;QAClC,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC,CAAC;KACjE;IAED;;OAEG;IACH,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE;QACvB,OAAO,IAAA,kCAA0B,EAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC;KAClE;IAED;;OAEG;IACH,MAAM,WAAW,GAAG,IAAA,sBAAiB,GAAE,CAAC;IACxC,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;QACvB,WAAW,CAAC,QAAQ,CAAC,IAAI,CACvB,IAAA,kCAA0B,EAAC,MAAM,EAAE,KAAK,EAAE,UAAU,CAAC,CACtD,CAAC;IACJ,CAAC,CAAC,CAAC;IACH,OAAO,WAAW,CAAC;AACrB,CAAC,CAAC;AAxBW,QAAA,oBAAoB,wBAwB/B"}

package/src/cube-filter-transformer/not-equals/not-equals-array.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notEqualsArrayTransform = void 0;
+const equals_array_1 = require("../equals/equals-array");
+const not_1 = require("../not/not");
+const notEqualsArrayTransform = (query) => {
+    const { values } = query;
+    if (!values || values.length === 0) {
+        throw new Error('Equals filter must have at least one value');
+    }
+    const notWrapper = (0, not_1.notDuckdbCondition)();
+    const equalsCondition = (0, equals_array_1.equalsArrayTransform)(query);
+    /**
+     * We need to wrap the equals condition in a not condition
+     * Which basically means ! of ANY of the values
+     */
+    notWrapper.children = [equalsCondition];
+    return notWrapper;
+};
+exports.notEqualsArrayTransform = notEqualsArrayTransform;
+//# sourceMappingURL=not-equals-array.js.map

package/src/cube-filter-transformer/not-equals/not-equals-array.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"not-equals-array.js","sourceRoot":"","sources":["../../../../../meerkat-core/src/cube-filter-transformer/not-equals/not-equals-array.ts"],"names":[],"mappings":";;;AAAA,yDAA8D;AAE9D,oCAAgD;AAEzC,MAAM,uBAAuB,GAAmC,CACrE,KAAK,EACL,EAAE;IACF,MAAM,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC;IAEzB,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE;QAClC,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;KAC/D;IAED,MAAM,UAAU,GAAG,IAAA,wBAAkB,GAAE,CAAC;IACxC,MAAM,eAAe,GAAG,IAAA,mCAAoB,EAAC,KAAK,CAAC,CAAC;IACpD;;;OAGG;IACH,UAAU,CAAC,QAAQ,GAAG,CAAC,eAAe,CAAC,CAAC;IAExC,OAAO,UAAU,CAAC;AACpB,CAAC,CAAC;AAlBW,QAAA,uBAAuB,2BAkBlC"}

package/src/cube-filter-transformer/not-equals/not-equals.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notEqualsTransform = void 0;
+const Expression_1 = require("../../types/duckdb-serialization-types/serialization/Expression");
+const is_array_member_type_1 = require("../../utils/is-array-member-type");
+const base_condition_builder_1 = require("../base-condition-builder/base-condition-builder");
+const or_1 = require("../or/or");
+const not_equals_array_1 = require("./not-equals-array");
+const notEqualsTransform = (query) => {
+    const { member, values } = query;
+    if (!values || values.length === 0) {
+        throw new Error('Equals filter must have at least one value');
+    }
+    /**
+     * If the member is an array, we need to use the array transform
+     */
+    if ((0, is_array_member_type_1.isArrayTypeMember)(query.memberInfo.type)) {
+        return (0, not_equals_array_1.notEqualsArrayTransform)(query);
+    }
+    /**
+     * If there is only one value, we can create a simple equals condition
+     */
+    if (values.length === 1) {
+        return (0, base_condition_builder_1.baseDuckdbCondition)(member, Expression_1.ExpressionType.COMPARE_NOTEQUAL, values[0], query.memberInfo);
+    }
+    /**
+     * If there are multiple values, we need to create an OR condition
+     */
+    const orCondition = (0, or_1.orDuckdbCondition)();
+    values.forEach((value) => {
+        orCondition.children.push((0, base_condition_builder_1.baseDuckdbCondition)(member, Expression_1.ExpressionType.COMPARE_NOTEQUAL, value, query.memberInfo));
+    });
+    return orCondition;
+};
+exports.notEqualsTransform = notEqualsTransform;
+//# sourceMappingURL=not-equals.js.map

package/src/cube-filter-transformer/not-equals/not-equals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"not-equals.js","sourceRoot":"","sources":["../../../../../meerkat-core/src/cube-filter-transformer/not-equals/not-equals.ts"],"names":[],"mappings":";;;AACA,gGAAiG;AACjG,2EAAqE;AACrE,6FAAuF;AAEvF,iCAA6C;AAC7C,yDAA6D;AAQtD,MAAM,kBAAkB,GAAmC,CAAC,KAAK,EAAE,EAAE;IAC1E,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC;IAEjC,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE;QAClC,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;KAC/D;IAED;;OAEG;IACH,IAAI,IAAA,wCAAiB,EAAC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE;QAC5C,OAAO,IAAA,0CAAuB,EAAC,KAAK,CAAC,CAAC;KACvC;IAED;;OAEG;IACH,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE;QACvB,OAAO,IAAA,4CAAmB,EACxB,MAAM,EACN,2BAAc,CAAC,gBAAgB,EAC/B,MAAM,CAAC,CAAC,CAAC,EACT,KAAK,CAAC,UAAU,CACjB,CAAC;KACH;IAED;;OAEG;IACH,MAAM,WAAW,GAAG,IAAA,sBAAiB,GAAE,CAAC;IACxC,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;QACvB,WAAW,CAAC,QAAQ,CAAC,IAAI,CACvB,IAAA,4CAAmB,EACjB,MAAM,EACN,2BAAc,CAAC,gBAAgB,EAC/B,KAAK,EACL,KAAK,CAAC,UAAU,CACjB,CACF,CAAC;IACJ,CAAC,CAAC,CAAC;IACH,OAAO,WAAW,CAAC;AACrB,CAAC,CAAC;AAzCW,QAAA,kBAAkB,sBAyC7B"}

package/src/cube-filter-transformer/not-in/not-in.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notInTransform = void 0;
+const constants_1 = require("../../member-formatters/constants");
+const Expression_1 = require("../../types/duckdb-serialization-types/serialization/Expression");
+const base_condition_builder_1 = require("../base-condition-builder/base-condition-builder");
+const notInDuckDbCondition = (columnName, values, memberInfo) => {
+    const sqlTreeValues = values.map((value) => {
+        return {
+            class: Expression_1.ExpressionClass.CONSTANT,
+            type: Expression_1.ExpressionType.VALUE_CONSTANT,
+            alias: '',
+            value: (0, base_condition_builder_1.valueBuilder)(value, memberInfo),
+        };
+    });
+    const columnRef = {
+        class: 'COLUMN_REF',
+        type: 'COLUMN_REF',
+        alias: '',
+        column_names: columnName.split(constants_1.COLUMN_NAME_DELIMITER),
+    };
+    switch (memberInfo.type) {
+        case 'number_array':
+        case 'string_array': {
+            return {
+                class: Expression_1.ExpressionClass.OPERATOR,
+                type: Expression_1.ExpressionType.OPERATOR_NOT,
+                alias: '',
+                children: [
+                    {
+                        class: Expression_1.ExpressionClass.FUNCTION,
+                        type: Expression_1.ExpressionType.FUNCTION,
+                        alias: '',
+                        function_name: '&&',
+                        schema: '',
+                        children: [
+                            columnRef,
+                            {
+                                class: Expression_1.ExpressionClass.OPERATOR,
+                                type: Expression_1.ExpressionType.ARRAY_CONSTRUCTOR,
+                                alias: '',
+                                children: sqlTreeValues,
+                            },
+                        ],
+                        filter: null,
+                        order_bys: {
+                            type: 'ORDER_MODIFIER',
+                            orders: [],
+                        },
+                        distinct: false,
+                        is_operator: true,
+                        export_state: false,
+                        catalog: '',
+                    },
+                ],
+            };
+        }
+        default: {
+            return {
+                class: Expression_1.ExpressionClass.OPERATOR,
+                type: Expression_1.ExpressionType.COMPARE_NOT_IN,
+                alias: '',
+                children: [columnRef, ...sqlTreeValues],
+            };
+        }
+    }
+};
+const notInTransform = (query) => {
+    const { member, values, memberInfo } = query;
+    if (!values) {
+        throw new Error('Not in filter must have at least one value');
+    }
+    return notInDuckDbCondition(member, values, memberInfo);
+};
+exports.notInTransform = notInTransform;
+//# sourceMappingURL=not-in.js.map

package/src/cube-filter-transformer/not-in/not-in.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"not-in.js","sourceRoot":"","sources":["../../../../../meerkat-core/src/cube-filter-transformer/not-in/not-in.ts"],"names":[],"mappings":";;;AAGA,iEAA0E;AAC1E,gGAGyE;AACzE,6FAAgF;AAEhF,MAAM,oBAAoB,GAAG,CAC3B,UAAkB,EAClB,MAAgB,EAChB,UAA+B,EAC/B,EAAE;IACF,MAAM,aAAa,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;QACzC,OAAO;YACL,KAAK,EAAE,4BAAe,CAAC,QAAQ;YAC/B,IAAI,EAAE,2BAAc,CAAC,cAAc;YACnC,KAAK,EAAE,EAAE;YACT,KAAK,EAAE,IAAA,qCAAY,EAAC,KAAK,EAAE,UAAU,CAAC;SACvC,CAAC;IACJ,CAAC,CAAC,CAAC;IACH,MAAM,SAAS,GAAG;QAChB,KAAK,EAAE,YAAY;QACnB,IAAI,EAAE,YAAY;QAClB,KAAK,EAAE,EAAE;QACT,YAAY,EAAE,UAAU,CAAC,KAAK,CAAC,iCAAqB,CAAC;KACtD,CAAC;IACF,QAAQ,UAAU,CAAC,IAAI,EAAE;QACvB,KAAK,cAAc,CAAC;QACpB,KAAK,cAAc,CAAC,CAAC;YACnB,OAAO;gBACL,KAAK,EAAE,4BAAe,CAAC,QAAQ;gBAC/B,IAAI,EAAE,2BAAc,CAAC,YAAY;gBACjC,KAAK,EAAE,EAAE;gBACT,QAAQ,EAAE;oBACR;wBACE,KAAK,EAAE,4BAAe,CAAC,QAAQ;wBAC/B,IAAI,EAAE,2BAAc,CAAC,QAAQ;wBAC7B,KAAK,EAAE,EAAE;wBACT,aAAa,EAAE,IAAI;wBACnB,MAAM,EAAE,EAAE;wBACV,QAAQ,EAAE;4BACR,SAAS;4BACT;gCACE,KAAK,EAAE,4BAAe,CAAC,QAAQ;gCAC/B,IAAI,EAAE,2BAAc,CAAC,iBAAiB;gCACtC,KAAK,EAAE,EAAE;gCACT,QAAQ,EAAE,aAAa;6BACxB;yBACF;wBACD,MAAM,EAAE,IAAI;wBACZ,SAAS,EAAE;4BACT,IAAI,EAAE,gBAAgB;4BACtB,MAAM,EAAE,EAAE;yBACX;wBACD,QAAQ,EAAE,KAAK;wBACf,WAAW,EAAE,IAAI;wBACjB,YAAY,EAAE,KAAK;wBACnB,OAAO,EAAE,EAAE;qBACZ;iBACF;aACF,CAAC;SACH;QACD,OAAO,CAAC,CAAC;YACP,OAAO;gBACL,KAAK,EAAE,4BAAe,CAAC,QAAQ;gBAC/B,IAAI,EAAE,2BAAc,CAAC,cAAc;gBACnC,KAAK,EAAE,EAAE;gBACT,QAAQ,EAAE,CAAC,SAAS,EAAE,GAAG,aAAa,CAAC;aACxC,CAAC;SACH;KACF;AACH,CAAC,CAAC;AAEK,MAAM,cAAc,GAAmC,CAAC,KAAK,EAAE,EAAE;IACtE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,KAAK,CAAC;IAC7C,IAAI,CAAC,MAAM,EAAE;QACX,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;KAC/D;IAED,OAAO,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC;AAC1D,CAAC,CAAC;AAPW,QAAA,cAAc,kBAOzB"}