@malloydata/malloy 0.0.24-dev230224184907 → 0.0.24-dev230228224434

package/dist/lang/ast/error-factory.js

@@ -24,18 +24,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ErrorFactory = void 0;
 const theErrorStruct = {
-    "type": "struct",
-    "name": "~malformed~",
-    "dialect": "~malformed~",
-    "structSource": {
-        "type": "table",
-        "tablePath": "//undefined_error_table_path"
+    type: 'struct',
+    name: '~malformed~',
+    dialect: '~malformed~',
+    structSource: {
+        type: 'table',
+        tablePath: '//undefined_error_table_path',
     },
-    "structRelationship": {
-        "type": "basetable",
-        "connectionName": "//undefined_error_connection"
+    structRelationship: {
+        type: 'basetable',
+        connectionName: '//undefined_error_connection',
     },
-    "fields": []
+    fields: [],
 };
 class ErrorFactory {
     static get structDef() {
@@ -46,18 +46,18 @@ class ErrorFactory {
     }
     static get query() {
         return {
-            "structRef": ErrorFactory.structDef,
-            "pipeline": []
+            structRef: ErrorFactory.structDef,
+            pipeline: [],
         };
     }
     static get reduceSegment() {
-        return { "type": "reduce", "fields": [] };
+        return { type: 'reduce', fields: [] };
     }
     static get projectSegment() {
-        return { "type": "project", "fields": [] };
+        return { type: 'project', fields: [] };
     }
     static get indexSegment() {
-        return { "type": "index", "fields": [] };
+        return { type: 'index', fields: [] };
     }
 }
 exports.ErrorFactory = ErrorFactory;

package/dist/lang/ast/executors/index-executor.d.ts

@@ -1,10 +1,10 @@
-import { FilterExpression, PipeSegment, Sampling } from "../../../model/malloy_types";
-import { FieldName, FieldSpace } from "../types/field-space";
-import { Limit } from "../query-properties/limit";
-import { IndexFieldSpace } from "../field-space/index-field-space";
-import { QueryProperty } from "../types/query-property";
-import { Executor } from "../types/executor";
-import { QueryInputSpace } from "../field-space/query-spaces";
+import { FilterExpression, PipeSegment, Sampling } from '../../../model/malloy_types';
+import { FieldName, FieldSpace } from '../types/field-space';
+import { Limit } from '../query-properties/limit';
+import { IndexFieldSpace } from '../field-space/index-field-space';
+import { QueryProperty } from '../types/query-property';
+import { Executor } from '../types/executor';
+import { QueryInputSpace } from '../field-space/query-spaces';
 export declare class IndexExecutor implements Executor {
     filters: FilterExpression[];
     limit?: Limit;

package/dist/lang/ast/executors/index-executor.js

@@ -41,7 +41,7 @@ class IndexExecutor {
         }
         else if (qp instanceof limit_1.Limit) {
             if (this.limit) {
-                this.limit.log("Ignored, too many limit: statements");
+                this.limit.log('Ignored, too many limit: statements');
             }
             this.limit = qp;
         }
@@ -49,7 +49,7 @@ class IndexExecutor {
             this.resultFS.addMembers(qp.fields.list);
             if (qp.weightBy) {
                 if (this.indexOn) {
-                    this.indexOn.log("Ignoring previous BY");
+                    this.indexOn.log('Ignoring previous BY');
                 }
                 this.indexOn = qp.weightBy;
             }
@@ -58,11 +58,11 @@ class IndexExecutor {
             this.sample = qp.sampling();
         }
         else {
-            qp.log("Not legal in an index query operation");
+            qp.log('Not legal in an index query operation');
         }
     }
     finalize(from) {
-        if (from && from.type !== "index") {
+        if (from && from.type !== 'index') {
             this.resultFS.log(`Can't refine index with ${from.type}`);
             return error_factory_1.ErrorFactory.indexSegment;
         }

package/dist/lang/ast/executors/project-executor.d.ts

@@ -1,8 +1,8 @@
-import { PipeSegment } from "../../../model/malloy_types";
-import { FieldSpace } from "../types/field-space";
-import { ProjectFieldSpace } from "../field-space/project-field-space";
-import { QueryProperty } from "../types/query-property";
-import { ReduceExecutor } from "./reduce-executor";
+import { PipeSegment } from '../../../model/malloy_types';
+import { FieldSpace } from '../types/field-space';
+import { ProjectFieldSpace } from '../field-space/project-field-space';
+import { QueryProperty } from '../types/query-property';
+import { ReduceExecutor } from './reduce-executor';
 export declare class ProjectExecutor extends ReduceExecutor {
     getResultSpace(fs: FieldSpace): ProjectFieldSpace;
     execute(qp: QueryProperty): void;

package/dist/lang/ast/executors/project-executor.js

@@ -39,10 +39,10 @@ class ProjectExecutor extends reduce_executor_1.ReduceExecutor {
         if (qp instanceof project_statement_1.ProjectStatement) {
             this.resultFS.addMembers(qp.list);
         }
-        else if ((qp instanceof filters_1.Filter && qp.elementType === "having") ||
+        else if ((qp instanceof filters_1.Filter && qp.elementType === 'having') ||
             qp instanceof measures_1.Measures ||
             qp instanceof group_by_1.GroupBy) {
-            qp.log("Illegal statement in a project query operation");
+            qp.log('Illegal statement in a project query operation');
         }
         else {
             super.execute(qp);

package/dist/lang/ast/executors/reduce-executor.d.ts

@@ -1,11 +1,11 @@
-import { FilterExpression, PipeSegment, QuerySegment } from "../../../model/malloy_types";
-import { FieldSpace } from "../types/field-space";
-import { Ordering } from "../query-properties/ordering";
-import { Top } from "../query-properties/top";
-import { QueryProperty } from "../types/query-property";
-import { Executor } from "../types/executor";
-import { QueryInputSpace, QuerySpace } from "../field-space/query-spaces";
-import { DynamicSpace } from "../field-space/dynamic-space";
+import { FilterExpression, PipeSegment, QuerySegment } from '../../../model/malloy_types';
+import { FieldSpace } from '../types/field-space';
+import { Ordering } from '../query-properties/ordering';
+import { Top } from '../query-properties/top';
+import { QueryProperty } from '../types/query-property';
+import { Executor } from '../types/executor';
+import { QueryInputSpace, QuerySpace } from '../field-space/query-spaces';
+import { DynamicSpace } from '../field-space/dynamic-space';
 export declare class ReduceExecutor implements Executor {
     inputFS: QueryInputSpace;
     resultFS: QuerySpace;

package/dist/lang/ast/executors/reduce-executor.js

@@ -59,14 +59,14 @@ class ReduceExecutor {
         }
         else if (qp instanceof top_1.Top) {
             if (this.limit) {
-                qp.log("Query operation already limited");
+                qp.log('Query operation already limited');
             }
             else {
                 this.limit = qp.limit;
             }
             if (qp.by) {
                 if (this.order) {
-                    qp.log("Query operation is already sorted");
+                    qp.log('Query operation is already sorted');
                 }
                 else {
                     this.order = qp;
@@ -75,7 +75,7 @@ class ReduceExecutor {
         }
         else if (qp instanceof limit_1.Limit) {
             if (this.limit) {
-                qp.log("Query operation already limited");
+                qp.log('Query operation already limited');
             }
             else {
                 this.limit = qp.limit;
@@ -83,7 +83,7 @@ class ReduceExecutor {
         }
         else if (qp instanceof ordering_1.Ordering) {
             if (this.order) {
-                qp.log("Query operation already sorted");
+                qp.log('Query operation already sorted');
             }
             else {
                 this.order = qp;
@@ -96,7 +96,7 @@ class ReduceExecutor {
         }
     }
     refineFrom(from, to) {
-        if (from && from.type !== "index") {
+        if (from && from.type !== 'index') {
             if (!this.order) {
                 if (from.orderBy) {
                     to.orderBy = from.orderBy;

package/dist/lang/ast/expressions/apply.d.ts

@@ -1,5 +1,5 @@
-import { ExprCompare } from "./expr-compare";
-import { ExpressionDef } from "../types/expression-def";
+import { ExprCompare } from './expr-compare';
+import { ExpressionDef } from '../types/expression-def';
 export declare class Apply extends ExprCompare {
     readonly left: ExpressionDef;
     readonly right: ExpressionDef;

package/dist/lang/ast/expressions/apply.js

@@ -30,7 +30,7 @@ class Apply extends expr_compare_1.ExprCompare {
         super(left, comparison_1.Comparison.EqualTo, right);
         this.left = left;
         this.right = right;
-        this.elementType = "apply";
+        this.elementType = 'apply';
     }
 }
 exports.Apply = Apply;

package/dist/lang/ast/expressions/binary-boolean.d.ts

@@ -1,6 +1,6 @@
-import { ExprValue } from "../types/expr-value";
-import { ExpressionDef } from "../types/expression-def";
-import { FieldSpace } from "../types/field-space";
+import { ExprValue } from '../types/expr-value';
+import { ExpressionDef } from '../types/expression-def';
+import { FieldSpace } from '../types/field-space';
 export declare abstract class BinaryBoolean<opType extends string> extends ExpressionDef {
     readonly left: ExpressionDef;
     readonly op: opType;

package/dist/lang/ast/expressions/binary-boolean.js

@@ -30,11 +30,11 @@ const expression_def_1 = require("../types/expression-def");
 const utils_1 = require("./utils");
 class BinaryBoolean extends expression_def_1.ExpressionDef {
     constructor(left, op, right) {
-        super({ "left": left, "right": right });
+        super({ left: left, right: right });
         this.left = left;
         this.op = op;
         this.right = right;
-        this.elementType = "abstract boolean binary";
+        this.elementType = 'abstract boolean binary';
         this.legalChildTypes = [fragtype_utils_1.FT.boolT];
     }
     getExpression(fs) {
@@ -42,12 +42,12 @@ class BinaryBoolean extends expression_def_1.ExpressionDef {
         const right = this.right.getExpression(fs);
         if (this.typeCheck(this.left, left) && this.typeCheck(this.right, right)) {
             return {
-                "dataType": "boolean",
-                "expressionType": (0, malloy_types_1.maxExpressionType)(left.expressionType, right.expressionType),
-                "value": (0, utils_1.compose)(left.value, this.op, right.value)
+                dataType: 'boolean',
+                expressionType: (0, malloy_types_1.maxExpressionType)(left.expressionType, right.expressionType),
+                value: (0, utils_1.compose)(left.value, this.op, right.value),
             };
         }
-        return (0, ast_utils_1.errorFor)("logial required boolean");
+        return (0, ast_utils_1.errorFor)('logial required boolean');
     }
 }
 exports.BinaryBoolean = BinaryBoolean;

package/dist/lang/ast/expressions/binary-numeric.d.ts

@@ -1,6 +1,6 @@
-import { ExprValue } from "../types/expr-value";
-import { ExpressionDef } from "../types/expression-def";
-import { FieldSpace } from "../types/field-space";
+import { ExprValue } from '../types/expr-value';
+import { ExpressionDef } from '../types/expression-def';
+import { FieldSpace } from '../types/field-space';
 export declare abstract class BinaryNumeric<opType extends string> extends ExpressionDef {
     readonly left: ExpressionDef;
     readonly op: opType;

package/dist/lang/ast/expressions/binary-numeric.js

@@ -27,11 +27,11 @@ const fragtype_utils_1 = require("../fragtype-utils");
 const expression_def_1 = require("../types/expression-def");
 class BinaryNumeric extends expression_def_1.ExpressionDef {
     constructor(left, op, right) {
-        super({ "left": left, "right": right });
+        super({ left: left, right: right });
         this.left = left;
         this.op = op;
         this.right = right;
-        this.elementType = "numeric binary abstract";
+        this.elementType = 'numeric binary abstract';
         this.legalChildTypes = [fragtype_utils_1.FT.numberT];
     }
     getExpression(fs) {

package/dist/lang/ast/expressions/boolean.d.ts

@@ -1,8 +1,8 @@
-import { ExprValue } from "../types/expr-value";
-import { ExpressionDef } from "../types/expression-def";
+import { ExprValue } from '../types/expr-value';
+import { ExpressionDef } from '../types/expression-def';
 export declare class Boolean extends ExpressionDef {
-    readonly value: "true" | "false";
+    readonly value: 'true' | 'false';
     elementType: string;
-    constructor(value: "true" | "false");
+    constructor(value: 'true' | 'false');
     getExpression(): ExprValue;
 }

package/dist/lang/ast/expressions/boolean.js

@@ -29,10 +29,10 @@ class Boolean extends expression_def_1.ExpressionDef {
     constructor(value) {
         super();
         this.value = value;
-        this.elementType = "boolean literal";
+        this.elementType = 'boolean literal';
     }
     getExpression() {
-        return { ...fragtype_utils_1.FT.boolT, "value": [this.value] };
+        return { ...fragtype_utils_1.FT.boolT, value: [this.value] };
     }
 }
 exports.Boolean = Boolean;

package/dist/lang/ast/expressions/constant-sub-expression.d.ts

@@ -1,7 +1,7 @@
-import { AtomicFieldType } from "../../../model/malloy_types";
-import { ExprValue } from "../types/expr-value";
-import { ExpressionDef } from "../types/expression-def";
-import { FieldSpace } from "../types/field-space";
+import { AtomicFieldType } from '../../../model/malloy_types';
+import { ExprValue } from '../types/expr-value';
+import { ExpressionDef } from '../types/expression-def';
+import { FieldSpace } from '../types/field-space';
 export declare class ConstantSubExpression extends ExpressionDef {
     readonly expr: ExpressionDef;
     elementType: string;

package/dist/lang/ast/expressions/constant-sub-expression.js

@@ -29,18 +29,18 @@ const expr_compare_1 = require("./expr-compare");
 const utils_1 = require("./utils");
 class ConstantFieldSpace {
     constructor() {
-        this.type = "fieldSpace";
+        this.type = 'fieldSpace';
     }
     structDef() {
-        throw new Error("ConstantFieldSpace cannot generate a structDef");
+        throw new Error('ConstantFieldSpace cannot generate a structDef');
     }
     emptyStructDef() {
-        throw new Error("ConstantFieldSpace cannot generate a structDef");
+        throw new Error('ConstantFieldSpace cannot generate a structDef');
     }
     lookup(_name) {
         return {
-            "error": "Only constants allowed in parameter expressions",
-            "found": undefined
+            error: 'Only constants allowed in parameter expressions',
+            found: undefined,
         };
     }
     dialectObj() {
@@ -54,21 +54,21 @@ class DollarReference extends expression_def_1.ExpressionDef {
     constructor(refType) {
         super();
         this.refType = refType;
-        this.elementType = "$";
+        this.elementType = '$';
     }
     getExpression(_fs) {
         return {
-            "dataType": this.refType,
-            "value": [{ "type": "applyVal" }],
-            "expressionType": "scalar"
+            dataType: this.refType,
+            value: [{ type: 'applyVal' }],
+            expressionType: 'scalar',
         };
     }
 }
 class ConstantSubExpression extends expression_def_1.ExpressionDef {
     constructor(expr) {
-        super({ "expr": expr });
+        super({ expr: expr });
         this.expr = expr;
-        this.elementType = "constantExpression";
+        this.elementType = 'constantExpression';
     }
     getExpression(_fs) {
         return this.constantValue();
@@ -85,7 +85,7 @@ class ConstantSubExpression extends expression_def_1.ExpressionDef {
     constantCondition(type) {
         const compareAndContrast = new expr_compare_1.ExprCompare(new DollarReference(type), comparison_1.Comparison.EqualTo, this.expr);
         const application = compareAndContrast.getExpression(this.constantFs);
-        return { ...application, "value": (0, utils_1.compressExpr)(application.value) };
+        return { ...application, value: (0, utils_1.compressExpr)(application.value) };
     }
     apply(fs, op, expr) {
         return this.expr.apply(fs, op, expr);

package/dist/lang/ast/expressions/expr-add-sub.d.ts

@@ -1,4 +1,4 @@
-import { BinaryNumeric } from "./binary-numeric";
-export declare class ExprAddSub extends BinaryNumeric<"+" | "-"> {
+import { BinaryNumeric } from './binary-numeric';
+export declare class ExprAddSub extends BinaryNumeric<'+' | '-'> {
     elementType: string;
 }

package/dist/lang/ast/expressions/expr-add-sub.js

@@ -27,7 +27,7 @@ const binary_numeric_1 = require("./binary-numeric");
 class ExprAddSub extends binary_numeric_1.BinaryNumeric {
     constructor() {
         super(...arguments);
-        this.elementType = "+-";
+        this.elementType = '+-';
     }
 }
 exports.ExprAddSub = ExprAddSub;

package/dist/lang/ast/expressions/expr-aggregate-function.d.ts

@@ -1,8 +1,8 @@
-import { FieldReference } from "../query-items/field-references";
-import { ExprValue } from "../types/expr-value";
-import { ExpressionDef } from "../types/expression-def";
-import { FieldSpace } from "../types/field-space";
-import { FieldValueType } from "../types/type-desc";
+import { FieldReference } from '../query-items/field-references';
+import { ExprValue } from '../types/expr-value';
+import { ExpressionDef } from '../types/expression-def';
+import { FieldSpace } from '../types/field-space';
+import { FieldValueType } from '../types/type-desc';
 export declare abstract class ExprAggregateFunction extends ExpressionDef {
     readonly func: string;
     elementType: string;

package/dist/lang/ast/expressions/expr-aggregate-function.js

@@ -36,11 +36,11 @@ class ExprAggregateFunction extends expression_def_1.ExpressionDef {
         this.elementType = func;
         if (expr) {
             this.expr = expr;
-            this.has({ "expr": expr });
+            this.has({ expr: expr });
         }
     }
     returns(_forExpression) {
-        return "number";
+        return 'number';
     }
     getExpression(fs) {
         var _a, _b;
@@ -52,9 +52,9 @@ class ExprAggregateFunction extends expression_def_1.ExpressionDef {
                 const footType = sourceFoot.typeDesc();
                 if ((0, malloy_types_1.isAtomicFieldType)(footType.dataType)) {
                     exprVal = {
-                        "dataType": footType.dataType,
-                        "expressionType": footType.expressionType,
-                        "value": [{ "type": "field", "path": this.source.refString }]
+                        dataType: footType.dataType,
+                        expressionType: footType.expressionType,
+                        value: [{ type: 'field', path: this.source.refString }],
                     };
                     structPath = this.source.sourceString;
                 }
@@ -71,28 +71,28 @@ class ExprAggregateFunction extends expression_def_1.ExpressionDef {
             }
         }
         if (exprVal === undefined) {
-            this.log("Missing expression for aggregate function");
-            return (0, ast_utils_1.errorFor)("agggregate without expression");
+            this.log('Missing expression for aggregate function');
+            return (0, ast_utils_1.errorFor)('agggregate without expression');
         }
         if (this.typeCheck(this.expr || this, {
             ...exprVal,
-            "expressionType": "scalar"
+            expressionType: 'scalar',
         })) {
             const f = {
-                "type": "aggregate",
-                "function": this.func,
-                "e": exprVal.value
+                type: 'aggregate',
+                function: this.func,
+                e: exprVal.value,
             };
             if (structPath) {
                 f.structPath = structPath;
             }
             return {
-                "dataType": this.returns(exprVal),
-                "expressionType": "aggregate",
-                "value": [f]
+                dataType: this.returns(exprVal),
+                expressionType: 'aggregate',
+                value: [f],
             };
         }
-        return (0, ast_utils_1.errorFor)("aggregate type check");
+        return (0, ast_utils_1.errorFor)('aggregate type check');
     }
 }
 exports.ExprAggregateFunction = ExprAggregateFunction;

package/dist/lang/ast/expressions/expr-alternation-tree.d.ts

@@ -1,10 +1,10 @@
-import { ExprValue } from "../types/expr-value";
-import { BinaryBoolean } from "./binary-boolean";
-import { FieldSpace } from "../types/field-space";
-import { ExpressionDef } from "../types/expression-def";
-export declare class ExprAlternationTree extends BinaryBoolean<"|" | "&"> {
+import { ExprValue } from '../types/expr-value';
+import { BinaryBoolean } from './binary-boolean';
+import { FieldSpace } from '../types/field-space';
+import { ExpressionDef } from '../types/expression-def';
+export declare class ExprAlternationTree extends BinaryBoolean<'|' | '&'> {
     elementType: string;
-    constructor(left: ExpressionDef, op: "|" | "&", right: ExpressionDef);
+    constructor(left: ExpressionDef, op: '|' | '&', right: ExpressionDef);
     apply(fs: FieldSpace, applyOp: string, expr: ExpressionDef): ExprValue;
     requestExpression(_fs: FieldSpace): ExprValue | undefined;
     getExpression(_fs: FieldSpace): ExprValue;

package/dist/lang/ast/expressions/expr-alternation-tree.js

@@ -30,24 +30,24 @@ const utils_1 = require("./utils");
 class ExprAlternationTree extends binary_boolean_1.BinaryBoolean {
     constructor(left, op, right) {
         super(left, op, right);
-        this.elementType = "alternation";
+        this.elementType = 'alternation';
         this.elementType = `${op}alternation${op}`;
     }
     apply(fs, applyOp, expr) {
         const choice1 = this.left.apply(fs, applyOp, expr);
         const choice2 = this.right.apply(fs, applyOp, expr);
         return {
-            "dataType": "boolean",
-            "expressionType": (0, malloy_types_1.maxExpressionType)(choice1.expressionType, choice2.expressionType),
-            "value": (0, utils_1.compose)(choice1.value, this.op === "&" ? "and" : "or", choice2.value)
+            dataType: 'boolean',
+            expressionType: (0, malloy_types_1.maxExpressionType)(choice1.expressionType, choice2.expressionType),
+            value: (0, utils_1.compose)(choice1.value, this.op === '&' ? 'and' : 'or', choice2.value),
         };
     }
     requestExpression(_fs) {
         return undefined;
     }
     getExpression(_fs) {
-        this.log(`Alternation tree has no value`);
-        return (0, ast_utils_1.errorFor)("no value from alternation tree");
+        this.log('Alternation tree has no value');
+        return (0, ast_utils_1.errorFor)('no value from alternation tree');
     }
 }
 exports.ExprAlternationTree = ExprAlternationTree;

package/dist/lang/ast/expressions/expr-asymmetric.d.ts

@@ -1,10 +1,10 @@
-import { FieldReference } from "../query-items/field-references";
-import { ExpressionDef } from "../types/expression-def";
-import { ExprAggregateFunction } from "./expr-aggregate-function";
+import { FieldReference } from '../query-items/field-references';
+import { ExpressionDef } from '../types/expression-def';
+import { ExprAggregateFunction } from './expr-aggregate-function';
 export declare abstract class ExprAsymmetric extends ExprAggregateFunction {
-    readonly func: "sum" | "avg";
+    readonly func: 'sum' | 'avg';
     readonly expr: ExpressionDef | undefined;
     readonly source?: FieldReference | undefined;
-    constructor(func: "sum" | "avg", expr: ExpressionDef | undefined, source?: FieldReference | undefined);
+    constructor(func: 'sum' | 'avg', expr: ExpressionDef | undefined, source?: FieldReference | undefined);
     defaultFieldName(): undefined | string;
 }

package/dist/lang/ast/expressions/expr-asymmetric.js

@@ -30,15 +30,15 @@ class ExprAsymmetric extends expr_aggregate_function_1.ExprAggregateFunction {
         this.func = func;
         this.expr = expr;
         this.source = source;
-        this.has({ "source": source });
+        this.has({ source: source });
     }
     defaultFieldName() {
         if (this.source && this.expr === undefined) {
             const tag = this.source.nameString;
             switch (this.func) {
-                case "sum":
+                case 'sum':
                     return `total_${tag}`;
-                case "avg":
+                case 'avg':
                     return `avg_${tag}`;
             }
         }

package/dist/lang/ast/expressions/expr-avg.d.ts

@@ -1,6 +1,6 @@
-import { FieldReference } from "../query-items/field-references";
-import { ExpressionDef } from "../types/expression-def";
-import { ExprAsymmetric } from "./expr-asymmetric";
+import { FieldReference } from '../query-items/field-references';
+import { ExpressionDef } from '../types/expression-def';
+import { ExprAsymmetric } from './expr-asymmetric';
 export declare class ExprAvg extends ExprAsymmetric {
     constructor(expr: ExpressionDef | undefined, source?: FieldReference);
 }

package/dist/lang/ast/expressions/expr-avg.js

@@ -26,8 +26,8 @@ exports.ExprAvg = void 0;
 const expr_asymmetric_1 = require("./expr-asymmetric");
 class ExprAvg extends expr_asymmetric_1.ExprAsymmetric {
     constructor(expr, source) {
-        super("avg", expr, source);
-        this.has({ "source": source });
+        super('avg', expr, source);
+        this.has({ source: source });
     }
 }
 exports.ExprAvg = ExprAvg;

package/dist/lang/ast/expressions/expr-cast.d.ts

@@ -1,7 +1,7 @@
-import { ExprValue } from "../types/expr-value";
-import { ExpressionDef } from "../types/expression-def";
-import { FieldSpace } from "../types/field-space";
-export declare type CastType = "string" | "number" | "boolean" | "date" | "timestamp";
+import { ExprValue } from '../types/expr-value';
+import { ExpressionDef } from '../types/expression-def';
+import { FieldSpace } from '../types/field-space';
+export declare type CastType = 'string' | 'number' | 'boolean' | 'date' | 'timestamp';
 export declare function isCastType(t: string): t is CastType;
 export declare class ExprCast extends ExpressionDef {
     readonly expr: ExpressionDef;