@malloydata/malloy 0.0.24-dev230224184907 → 0.0.24-dev230228224434

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

@@ -27,23 +27,23 @@ const time_utils_1 = require("../time-utils");
 const expression_def_1 = require("../types/expression-def");
 const utils_1 = require("./utils");
 function isCastType(t) {
-    return ["string", "number", "boolean", "date", "timestamp"].includes(t);
+    return ['string', 'number', 'boolean', 'date', 'timestamp'].includes(t);
 }
 exports.isCastType = isCastType;
 class ExprCast extends expression_def_1.ExpressionDef {
     constructor(expr, castType, safe = false) {
-        super({ "expr": expr });
+        super({ expr: expr });
         this.expr = expr;
         this.castType = castType;
         this.safe = safe;
-        this.elementType = "cast";
+        this.elementType = 'cast';
     }
     getExpression(fs) {
         const expr = this.expr.getExpression(fs);
         return {
-            "dataType": this.castType,
-            "expressionType": expr.expressionType,
-            "value": (0, utils_1.compressExpr)((0, time_utils_1.castTo)(this.castType, expr.value, this.safe))
+            dataType: this.castType,
+            expressionType: expr.expressionType,
+            value: (0, utils_1.compressExpr)((0, time_utils_1.castTo)(this.castType, expr.value, this.safe)),
         };
     }
 }

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

@@ -1,8 +1,8 @@
-import { Comparison } from "../types/comparison";
-import { ExprValue } from "../types/expr-value";
-import { ExpressionDef } from "../types/expression-def";
-import { FieldSpace } from "../types/field-space";
-import { BinaryBoolean } from "./binary-boolean";
+import { Comparison } from '../types/comparison';
+import { ExprValue } from '../types/expr-value';
+import { ExpressionDef } from '../types/expression-def';
+import { FieldSpace } from '../types/field-space';
+import { BinaryBoolean } from './binary-boolean';
 export declare class ExprCompare extends BinaryBoolean<Comparison> {
     elementType: string;
     constructor(left: ExpressionDef, op: Comparison, right: ExpressionDef);

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

@@ -28,19 +28,19 @@ const granular_result_1 = require("../types/granular-result");
 const binary_boolean_1 = require("./binary-boolean");
 const expr_granular_time_1 = require("./expr-granular-time");
 const compareTypes = {
-    "~": [fragtype_utils_1.FT.stringT],
-    "!~": [fragtype_utils_1.FT.stringT],
-    "<": [fragtype_utils_1.FT.numberT, fragtype_utils_1.FT.stringT, fragtype_utils_1.FT.dateT, fragtype_utils_1.FT.timestampT],
-    "<=": [fragtype_utils_1.FT.numberT, fragtype_utils_1.FT.stringT, fragtype_utils_1.FT.dateT, fragtype_utils_1.FT.timestampT],
-    "=": [fragtype_utils_1.FT.numberT, fragtype_utils_1.FT.stringT, fragtype_utils_1.FT.dateT, fragtype_utils_1.FT.timestampT],
-    "!=": [fragtype_utils_1.FT.numberT, fragtype_utils_1.FT.stringT, fragtype_utils_1.FT.dateT, fragtype_utils_1.FT.timestampT],
-    ">=": [fragtype_utils_1.FT.numberT, fragtype_utils_1.FT.stringT, fragtype_utils_1.FT.dateT, fragtype_utils_1.FT.timestampT],
-    ">": [fragtype_utils_1.FT.numberT, fragtype_utils_1.FT.stringT, fragtype_utils_1.FT.dateT, fragtype_utils_1.FT.timestampT]
+    '~': [fragtype_utils_1.FT.stringT],
+    '!~': [fragtype_utils_1.FT.stringT],
+    '<': [fragtype_utils_1.FT.numberT, fragtype_utils_1.FT.stringT, fragtype_utils_1.FT.dateT, fragtype_utils_1.FT.timestampT],
+    '<=': [fragtype_utils_1.FT.numberT, fragtype_utils_1.FT.stringT, fragtype_utils_1.FT.dateT, fragtype_utils_1.FT.timestampT],
+    '=': [fragtype_utils_1.FT.numberT, fragtype_utils_1.FT.stringT, fragtype_utils_1.FT.dateT, fragtype_utils_1.FT.timestampT],
+    '!=': [fragtype_utils_1.FT.numberT, fragtype_utils_1.FT.stringT, fragtype_utils_1.FT.dateT, fragtype_utils_1.FT.timestampT],
+    '>=': [fragtype_utils_1.FT.numberT, fragtype_utils_1.FT.stringT, fragtype_utils_1.FT.dateT, fragtype_utils_1.FT.timestampT],
+    '>': [fragtype_utils_1.FT.numberT, fragtype_utils_1.FT.stringT, fragtype_utils_1.FT.dateT, fragtype_utils_1.FT.timestampT],
 };
 class ExprCompare extends binary_boolean_1.BinaryBoolean {
     constructor(left, op, right) {
         super(left, op, right);
-        this.elementType = "a<=>b";
+        this.elementType = 'a<=>b';
         this.legalChildTypes = compareTypes[op];
     }
     getExpression(fs) {

package/dist/lang/ast/expressions/expr-count-distinct.d.ts

@@ -1,5 +1,5 @@
-import { ExprAggregateFunction } from "./expr-aggregate-function";
-import { ExpressionDef } from "../types/expression-def";
+import { ExprAggregateFunction } from './expr-aggregate-function';
+import { ExpressionDef } from '../types/expression-def';
 export declare class ExprCountDistinct extends ExprAggregateFunction {
     legalChildTypes: import("../types/type-desc").TypeDesc[];
     constructor(expr: ExpressionDef);

package/dist/lang/ast/expressions/expr-count-distinct.js

@@ -27,7 +27,7 @@ const fragtype_utils_1 = require("../fragtype-utils");
 const expr_aggregate_function_1 = require("./expr-aggregate-function");
 class ExprCountDistinct extends expr_aggregate_function_1.ExprAggregateFunction {
     constructor(expr) {
-        super("count_distinct", expr);
+        super('count_distinct', expr);
         this.legalChildTypes = [fragtype_utils_1.FT.numberT, fragtype_utils_1.FT.stringT, fragtype_utils_1.FT.dateT, fragtype_utils_1.FT.timestampT];
     }
 }

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

@@ -1,7 +1,7 @@
-import { FieldReference } from "../query-items/field-references";
-import { ExprValue } from "../types/expr-value";
-import { FieldSpace } from "../types/field-space";
-import { ExprAggregateFunction } from "./expr-aggregate-function";
+import { FieldReference } from '../query-items/field-references';
+import { ExprValue } from '../types/expr-value';
+import { FieldSpace } from '../types/field-space';
+import { ExprAggregateFunction } from './expr-aggregate-function';
 export declare class ExprCount extends ExprAggregateFunction {
     readonly source?: FieldReference | undefined;
     elementType: string;

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

@@ -26,30 +26,30 @@ exports.ExprCount = void 0;
 const expr_aggregate_function_1 = require("./expr-aggregate-function");
 class ExprCount extends expr_aggregate_function_1.ExprAggregateFunction {
     constructor(source) {
-        super("count");
+        super('count');
         this.source = source;
-        this.elementType = "count";
-        this.has({ "source": source });
+        this.elementType = 'count';
+        this.has({ source: source });
     }
     defaultFieldName() {
         if (this.source) {
-            return "count_" + this.source.nameString;
+            return 'count_' + this.source.nameString;
         }
         return undefined;
     }
     getExpression(_fs) {
         const ret = {
-            "type": "aggregate",
-            "function": "count",
-            "e": []
+            type: 'aggregate',
+            function: 'count',
+            e: [],
         };
         if (this.source) {
             ret.structPath = this.source.refString;
         }
         return {
-            "dataType": "number",
-            "expressionType": "aggregate",
-            "value": [ret]
+            dataType: 'number',
+            expressionType: 'aggregate',
+            value: [ret],
         };
     }
 }

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

@@ -1,7 +1,7 @@
-import { Filter } from "../query-properties/filters";
-import { ExprValue } from "../types/expr-value";
-import { ExpressionDef } from "../types/expression-def";
-import { FieldSpace } from "../types/field-space";
+import { Filter } from '../query-properties/filters';
+import { ExprValue } from '../types/expr-value';
+import { ExpressionDef } from '../types/expression-def';
+import { FieldSpace } from '../types/field-space';
 export declare class ExprFilter extends ExpressionDef {
     readonly expr: ExpressionDef;
     readonly filter: Filter;

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

@@ -29,10 +29,10 @@ const fragtype_utils_1 = require("../fragtype-utils");
 const expression_def_1 = require("../types/expression-def");
 class ExprFilter extends expression_def_1.ExpressionDef {
     constructor(expr, filter) {
-        super({ "expr": expr, "filter": filter });
+        super({ expr: expr, filter: filter });
         this.expr = expr;
         this.filter = filter;
-        this.elementType = "filtered expression";
+        this.elementType = 'filtered expression';
         this.legalChildTypes = fragtype_utils_1.FT.anyAtomicT;
     }
     getExpression(fs) {
@@ -40,29 +40,29 @@ class ExprFilter extends expression_def_1.ExpressionDef {
         const resultExpr = this.expr.getExpression(fs);
         for (const cond of testList) {
             if ((0, malloy_types_1.expressionIsCalculation)(cond.expressionType)) {
-                this.filter.log("Cannot filter a field with an aggregate or analytical computation");
-                return (0, ast_utils_1.errorFor)("no filter on aggregate");
+                this.filter.log('Cannot filter a field with an aggregate or analytical computation');
+                return (0, ast_utils_1.errorFor)('no filter on aggregate');
             }
         }
-        if (resultExpr.expressionType === "scalar") {
+        if (resultExpr.expressionType === 'scalar') {
             // TODO could log a warning, but I have a problem with the
             // idea of warnings, so for now ...
             return resultExpr;
         }
-        if (this.typeCheck(this.expr, { ...resultExpr, "expressionType": "scalar" })) {
+        if (this.typeCheck(this.expr, { ...resultExpr, expressionType: 'scalar' })) {
             return {
                 ...resultExpr,
-                "value": [
+                value: [
                     {
-                        "type": "filterExpression",
-                        "e": resultExpr.value,
-                        "filterList": testList
-                    }
-                ]
+                        type: 'filterExpression',
+                        e: resultExpr.value,
+                        filterList: testList,
+                    },
+                ],
             };
         }
         this.expr.log(`Cannot filter '${resultExpr.dataType}' data`);
-        return (0, ast_utils_1.errorFor)("cannot filter type");
+        return (0, ast_utils_1.errorFor)('cannot filter type');
     }
 }
 exports.ExprFilter = ExprFilter;

package/dist/lang/ast/expressions/expr-func.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 class ExprFunc extends ExpressionDef {
     readonly name: string;
     readonly args: ExpressionDef[];

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

@@ -28,34 +28,34 @@ const expression_def_1 = require("../types/expression-def");
 const utils_1 = require("./utils");
 class ExprFunc extends expression_def_1.ExpressionDef {
     constructor(name, args) {
-        super({ "args": args });
+        super({ args: args });
         this.name = name;
         this.args = args;
-        this.elementType = "function call()";
+        this.elementType = 'function call()';
     }
     getExpression(fs) {
         var _a, _b, _c;
-        let expressionType = "scalar";
+        let expressionType = 'scalar';
         let collectType;
         const funcCall = [`${this.name}(`];
         for (const fexpr of this.args) {
             const expr = fexpr.getExpression(fs);
             expressionType = (0, malloy_types_1.maxExpressionType)(expressionType, expr.expressionType);
             if (collectType) {
-                funcCall.push(",");
+                funcCall.push(',');
             }
             else {
                 collectType = expr.dataType;
             }
             funcCall.push(...expr.value);
         }
-        funcCall.push(")");
+        funcCall.push(')');
         const dialect = fs.dialectObj();
-        const dataType = (_c = (_b = (_a = dialect === null || dialect === void 0 ? void 0 : dialect.getFunctionInfo(this.name)) === null || _a === void 0 ? void 0 : _a.returnType) !== null && _b !== void 0 ? _b : collectType) !== null && _c !== void 0 ? _c : "number";
+        const dataType = (_c = (_b = (_a = dialect === null || dialect === void 0 ? void 0 : dialect.getFunctionInfo(this.name)) === null || _a === void 0 ? void 0 : _a.returnType) !== null && _b !== void 0 ? _b : collectType) !== null && _c !== void 0 ? _c : 'number';
         return {
-            "dataType": dataType,
+            dataType: dataType,
             expressionType,
-            "value": (0, utils_1.compressExpr)(funcCall)
+            value: (0, utils_1.compressExpr)(funcCall),
         };
     }
 }

package/dist/lang/ast/expressions/expr-granular-time.d.ts

@@ -1,7 +1,7 @@
-import { TimestampUnit } from "../../../model/malloy_types";
-import { ExprValue } from "../types/expr-value";
-import { ExpressionDef } from "../types/expression-def";
-import { FieldSpace } from "../types/field-space";
+import { TimestampUnit } from '../../../model/malloy_types';
+import { ExprValue } from '../types/expr-value';
+import { ExpressionDef } from '../types/expression-def';
+import { FieldSpace } from '../types/field-space';
 /**
  * GranularTime is a moment in time which ALSO has a "granularity"
  * commonly this are created by applying ".datePart" to an expression

package/dist/lang/ast/expressions/expr-granular-time.js

@@ -39,11 +39,11 @@ const range_1 = require("./range");
  */
 class ExprGranularTime extends expression_def_1.ExpressionDef {
     constructor(expr, units, truncate) {
-        super({ "expr": expr });
+        super({ expr: expr });
         this.expr = expr;
         this.units = units;
         this.truncate = truncate;
-        this.elementType = "granularTime";
+        this.elementType = 'granularTime';
         this.legalChildTypes = [fragtype_utils_1.FT.timestampT, fragtype_utils_1.FT.dateT];
     }
     granular() {
@@ -55,29 +55,29 @@ class ExprGranularTime extends expression_def_1.ExpressionDef {
         if ((0, malloy_types_1.isTimeFieldType)(exprVal.dataType)) {
             const tsVal = {
                 ...exprVal,
-                "dataType": exprVal.dataType,
-                "timeframe": timeframe
+                dataType: exprVal.dataType,
+                timeframe: timeframe,
             };
             if (this.truncate) {
                 tsVal.value = [
                     {
-                        "type": "dialect",
-                        "function": "trunc",
-                        "expr": { "value": exprVal.value, "valueType": exprVal.dataType },
-                        "units": timeframe
-                    }
+                        type: 'dialect',
+                        function: 'trunc',
+                        expr: { value: exprVal.value, valueType: exprVal.dataType },
+                        units: timeframe,
+                    },
                 ];
             }
             return tsVal;
         }
         this.log(`Cannot do time truncation on type '${exprVal.dataType}'`);
-        return (0, ast_utils_1.errorFor)(`granularity typecheck`);
+        return (0, ast_utils_1.errorFor)('granularity typecheck');
     }
     apply(fs, op, left) {
         const rangeType = this.getExpression(fs).dataType;
         const _valueType = left.getExpression(fs).dataType;
-        const granularityType = (0, malloy_types_1.isDateUnit)(this.units) ? "date" : "timestamp";
-        if (rangeType == "date" && granularityType == "date") {
+        const granularityType = (0, malloy_types_1.isDateUnit)(this.units) ? 'date' : 'timestamp';
+        if (rangeType === 'date' && granularityType === 'date') {
             return this.dateRange(fs, op, left);
         }
         return this.timestampRange(fs, op, left);
@@ -99,16 +99,16 @@ class ExprGranularTime extends expression_def_1.ExpressionDef {
     }
     timestampRange(fs, op, expr) {
         const begin = this.getExpression(fs);
-        const beginTime = expr_time_1.ExprTime.fromValue("timestamp", begin);
-        const endTime = new expr_time_1.ExprTime("timestamp", (0, time_utils_1.timeOffset)("timestamp", begin.value, "+", (0, malloy_types_1.mkExpr) `1`, this.units), begin.expressionType);
+        const beginTime = expr_time_1.ExprTime.fromValue('timestamp', begin);
+        const endTime = new expr_time_1.ExprTime('timestamp', (0, time_utils_1.timeOffset)('timestamp', begin.value, '+', (0, malloy_types_1.mkExpr) `1`, this.units), begin.expressionType);
         const range = new range_1.Range(beginTime, endTime);
         return range.apply(fs, op, expr);
     }
     dateRange(fs, op, expr) {
         const begin = this.getExpression(fs);
-        const beginTime = new expr_time_1.ExprTime("date", begin.value, begin.expressionType);
-        const endAt = (0, time_utils_1.timeOffset)("date", begin.value, "+", ["1"], this.units);
-        const end = new expr_time_1.ExprTime("date", endAt, begin.expressionType);
+        const beginTime = new expr_time_1.ExprTime('date', begin.value, begin.expressionType);
+        const endAt = (0, time_utils_1.timeOffset)('date', begin.value, '+', ['1'], this.units);
+        const end = new expr_time_1.ExprTime('date', endAt, begin.expressionType);
         const range = new range_1.Range(beginTime, end);
         return range.apply(fs, op, expr);
     }

package/dist/lang/ast/expressions/expr-id-reference.d.ts

@@ -1,7 +1,7 @@
-import { ExprValue } from "../types/expr-value";
-import { FieldReference } from "../query-items/field-references";
-import { FieldSpace } from "../types/field-space";
-import { ExpressionDef } from "../types/expression-def";
+import { ExprValue } from '../types/expr-value';
+import { FieldReference } from '../query-items/field-references';
+import { FieldSpace } from '../types/field-space';
+import { ExpressionDef } from '../types/expression-def';
 export declare class ExprIdReference extends ExpressionDef {
     readonly fieldReference: FieldReference;
     elementType: string;

package/dist/lang/ast/expressions/expr-id-reference.js

@@ -31,8 +31,8 @@ class ExprIdReference extends expression_def_1.ExpressionDef {
     constructor(fieldReference) {
         super();
         this.fieldReference = fieldReference;
-        this.elementType = "ExpressionIdReference";
-        this.has({ "fieldPath": fieldReference });
+        this.elementType = 'ExpressionIdReference';
+        this.has({ fieldPath: fieldReference });
     }
     get refString() {
         return this.fieldReference.refString;
@@ -40,7 +40,7 @@ class ExprIdReference extends expression_def_1.ExpressionDef {
     getExpression(fs) {
         const def = this.fieldReference.getField(fs);
         if (def.found) {
-            const value = [{ "type": def.found.refType, "path": this.refString }];
+            const value = [{ type: def.found.refType, path: this.refString }];
             const td = def.found.typeDesc();
             return { ...td, value };
         }
@@ -54,15 +54,15 @@ class ExprIdReference extends expression_def_1.ExpressionDef {
             if ((0, malloy_types_1.isConditionParameter)(cParam)) {
                 const lval = expr.getExpression(fs);
                 return {
-                    "dataType": "boolean",
-                    "expressionType": lval.expressionType,
-                    "value": [
+                    dataType: 'boolean',
+                    expressionType: lval.expressionType,
+                    value: [
                         {
-                            "type": "apply",
-                            "value": lval.value,
-                            "to": [{ "type": "parameter", "path": this.refString }]
-                        }
-                    ]
+                            type: 'apply',
+                            value: lval.value,
+                            to: [{ type: 'parameter', path: this.refString }],
+                        },
+                    ],
                 };
             }
         }

package/dist/lang/ast/expressions/expr-logical-op.d.ts

@@ -1,5 +1,5 @@
-import { BinaryBoolean } from "./binary-boolean";
-export declare class ExprLogicalOp extends BinaryBoolean<"and" | "or"> {
+import { BinaryBoolean } from './binary-boolean';
+export declare class ExprLogicalOp extends BinaryBoolean<'and' | 'or'> {
     elementType: string;
     legalChildTypes: import("../types/type-desc").TypeDesc[];
 }

package/dist/lang/ast/expressions/expr-logical-op.js

@@ -28,7 +28,7 @@ const fragtype_utils_1 = require("../fragtype-utils");
 class ExprLogicalOp extends binary_boolean_1.BinaryBoolean {
     constructor() {
         super(...arguments);
-        this.elementType = "logical operator";
+        this.elementType = 'logical operator';
         this.legalChildTypes = [fragtype_utils_1.FT.boolT, fragtype_utils_1.FT.aggregateBoolT];
     }
 }

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

@@ -1,7 +1,7 @@
-import { ExprValue } from "../types/expr-value";
-import { FieldValueType } from "../types/type-desc";
-import { ExprAggregateFunction } from "./expr-aggregate-function";
-import { ExpressionDef } from "../types/expression-def";
+import { ExprValue } from '../types/expr-value';
+import { FieldValueType } from '../types/type-desc';
+import { ExprAggregateFunction } from './expr-aggregate-function';
+import { ExpressionDef } from '../types/expression-def';
 export declare class ExprMax extends ExprAggregateFunction {
     legalChildTypes: import("../types/type-desc").TypeDesc[];
     constructor(expr: ExpressionDef);

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

@@ -27,7 +27,7 @@ const fragtype_utils_1 = require("../fragtype-utils");
 const expr_aggregate_function_1 = require("./expr-aggregate-function");
 class ExprMax extends expr_aggregate_function_1.ExprAggregateFunction {
     constructor(expr) {
-        super("max", expr);
+        super('max', expr);
         this.legalChildTypes = [fragtype_utils_1.FT.numberT, fragtype_utils_1.FT.stringT, fragtype_utils_1.FT.dateT, fragtype_utils_1.FT.timestampT];
     }
     returns(forExpression) {

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

@@ -1,7 +1,7 @@
-import { ExprValue } from "../types/expr-value";
-import { FieldValueType } from "../types/type-desc";
-import { ExprAggregateFunction } from "./expr-aggregate-function";
-import { ExpressionDef } from "../types/expression-def";
+import { ExprValue } from '../types/expr-value';
+import { FieldValueType } from '../types/type-desc';
+import { ExprAggregateFunction } from './expr-aggregate-function';
+import { ExpressionDef } from '../types/expression-def';
 export declare class ExprMin extends ExprAggregateFunction {
     legalChildTypes: import("../types/type-desc").TypeDesc[];
     constructor(expr: ExpressionDef);

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

@@ -27,7 +27,7 @@ const fragtype_utils_1 = require("../fragtype-utils");
 const expr_aggregate_function_1 = require("./expr-aggregate-function");
 class ExprMin extends expr_aggregate_function_1.ExprAggregateFunction {
     constructor(expr) {
-        super("min", expr);
+        super('min', expr);
         this.legalChildTypes = [fragtype_utils_1.FT.numberT, fragtype_utils_1.FT.stringT, fragtype_utils_1.FT.dateT, fragtype_utils_1.FT.timestampT];
     }
     returns(forExpression) {

package/dist/lang/ast/expressions/expr-minus.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 class ExprMinus extends ExpressionDef {
     readonly expr: ExpressionDef;
     elementType: string;

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

@@ -28,20 +28,20 @@ const fragtype_utils_1 = require("../fragtype-utils");
 const expression_def_1 = require("../types/expression-def");
 class ExprMinus extends expression_def_1.ExpressionDef {
     constructor(expr) {
-        super({ "expr": expr });
+        super({ expr: expr });
         this.expr = expr;
-        this.elementType = "unary minus";
+        this.elementType = 'unary minus';
         this.legalChildTypes = [fragtype_utils_1.FT.numberT];
     }
     getExpression(fs) {
         const expr = this.expr.getExpression(fs);
         if (this.typeCheck(this.expr, expr)) {
             if (expr.value.length > 1) {
-                return { ...expr, "value": ["-(", ...expr.value, ")"] };
+                return { ...expr, value: ['-(', ...expr.value, ')'] };
             }
-            return { ...expr, "value": ["-", ...expr.value] };
+            return { ...expr, value: ['-', ...expr.value] };
         }
-        return (0, ast_utils_1.errorFor)("negate requires number");
+        return (0, ast_utils_1.errorFor)('negate requires number');
     }
 }
 exports.ExprMinus = ExprMinus;

package/dist/lang/ast/expressions/expr-mul-div.d.ts

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

package/dist/lang/ast/expressions/expr-mul-div.js

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

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

@@ -1,7 +1,7 @@
-import { ExprValue } from "../types/expr-value";
-import { ExpressionDef } from "../types/expression-def";
-import { FieldSpace } from "../types/field-space";
-import { Unary } from "./unary";
+import { ExprValue } from '../types/expr-value';
+import { ExpressionDef } from '../types/expression-def';
+import { FieldSpace } from '../types/field-space';
+import { Unary } from './unary';
 export declare class ExprNot extends Unary {
     elementType: string;
     legalChildTypes: import("../types/type-desc").TypeDesc[];

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

@@ -29,7 +29,7 @@ const utils_1 = require("./utils");
 class ExprNot extends unary_1.Unary {
     constructor(expr) {
         super(expr);
-        this.elementType = "not";
+        this.elementType = 'not';
         this.legalChildTypes = [fragtype_utils_1.FT.boolT, fragtype_utils_1.FT.nullT];
     }
     getExpression(fs) {
@@ -37,8 +37,8 @@ class ExprNot extends unary_1.Unary {
         const doNot = this.typeCheck(this.expr, notThis);
         return {
             ...notThis,
-            "dataType": "boolean",
-            "value": doNot ? (0, utils_1.nullsafeNot)(notThis.value) : ["false"]
+            dataType: 'boolean',
+            value: doNot ? (0, utils_1.nullsafeNot)(notThis.value) : ['false'],
         };
     }
 }

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

@@ -1,6 +1,6 @@
-import { ExprValue } from "../types/expr-value";
-import { FieldSpace } from "../types/field-space";
-import { ExpressionDef } from "../types/expression-def";
+import { ExprValue } from '../types/expr-value';
+import { FieldSpace } from '../types/field-space';
+import { ExpressionDef } from '../types/expression-def';
 export declare class ExprNow extends ExpressionDef {
     elementType: string;
     getExpression(_fs: FieldSpace): ExprValue;

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

@@ -27,18 +27,18 @@ const expression_def_1 = require("../types/expression-def");
 class ExprNow extends expression_def_1.ExpressionDef {
     constructor() {
         super(...arguments);
-        this.elementType = "timestamp";
+        this.elementType = 'timestamp';
     }
     getExpression(_fs) {
         return {
-            "dataType": "timestamp",
-            "expressionType": "scalar",
-            "value": [
+            dataType: 'timestamp',
+            expressionType: 'scalar',
+            value: [
                 {
-                    "type": "dialect",
-                    "function": "now"
-                }
-            ]
+                    type: 'dialect',
+                    function: 'now',
+                },
+            ],
         };
     }
 }